在经典的汉诺塔问题中，有 3 个塔和 N 个可用来堆砌成塔的不同大小的盘子。要求盘子必须按照从小到大的顺序从上往下堆 （如，任意一个盘子，其必须堆在比它大的盘子上面）。同时，你必须满足以下限制条件：

(1) 每次只能移动一个盘子。
(2) 每个盘子从堆的顶部被移动后，只能置放于下一个堆中。
(3) 每个盘子只能放在比它大的盘子上面。

请写一段程序，实现将第一个堆的盘子移动到最后一个堆中。

思路：设三个塔分别为A B C ，B为起辅助作用的塔

第一步：将n-1个盘子从A柱移动至B柱（借助C柱为过渡柱）

第二步：将A柱底下最大的盘子移动至C柱

第三步：将B柱的n-1个盘子移至C柱（借助A柱为过渡柱）

递归算法

public class Tower {
    private Stack<Integer> disks;
    // create three towers (i from 0 to 2)
    public Tower(int i) {
        disks = new Stack<Integer>();
    }

    // Add a disk into this tower
    public void add(int d) {
        if (!disks.isEmpty() && disks.peek() <= d) {
            System.out.println(“Error placing disk ” + d);
        } else {
            disks.push(d);
        }
    }

    // @param t a tower
    // Move the top disk of this tower to the top of t.
    public void moveTopTo(Tower t) {
        // Write your code here
        t.add(disks.pop());
    }

    // @param n an integer
    // @param destination a tower
    // @param buffer a tower
    // Move n Disks from this tower to destination by buffer tower
    public void moveDisks(int n, Tower destination, Tower buffer) {
        // Write your code here
        if(n==1)
           moveTopTo(destination);
        if(n>1){//考虑到n==0的情况 所以这里不用else
            moveDisks(n-1,buffer, destination);
            moveTopTo(destination);
            buffer.moveDisks(n-1, destination,this);
        }
    }

    public Stack<Integer> getDisks() {
        return disks;
    }
}
/**
 * Your Tower object will be instantiated and called as such:
 * Tower[] towers = new Tower[3];
 * for (int i = 0; i < 3; i++) towers[i] = new Tower(i);
 * for (int i = n – 1; i >= 0; i–) towers[0].add(i);
 * towers[0].moveDisks(n, towers[2], towers[1]);
 * print towers[0], towers[1], towers[2]
*/

非递归算法

http://www.cnblogs.com/LYLtim/p/4280256.html[感觉还是递归的意思==]

http://blog.csdn.net/computerme/article/details/18080511【待理解】