用栈模拟汉诺塔问题

本是古典何须时尚 2022-06-12 10:28 125阅读 0赞

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

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

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

递归方式实现：

public static void move(int n,char from,char help,char to){
    		if(n==0){
    			return;
    		}
    		move(n-1, from, to, help);
    		System.out.println("move from "+from+" to "+to);
    		move(n-1, help, from, to);
    	}

用栈方式实现：

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==0)return;
            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]
    */