【算法笔记】使用栈实现汉诺塔(Hanoi)经典算法

汉诺塔(Hanoi)算法，应该是每一个程序员都会学习到的递推算法之一，汉诺塔是一个很著名的智力题，但是这里就不科普它的由来了，我们直接进入正题。

      如上图，假设A棒有五个原盘，依次移动，每次移动一块，小的永远只能在上面，最终移动到C棒上，如何用算法实现呢？
      从这里移动的逻辑我们很容易发现，A帮不就像一个栈吗，栈顶必须先出，网上看过很多汉诺塔算法，很少涉及到用栈实现，的确，算法拿出来了，用什么都一样，在我学习的时候，教材上是用的char，直接模拟推算，没用真正移动数据实现真正的Hanoi思想，所以，琢磨了一会，写了一个用栈实现的算法。
      首先，既然是栈，为了方便跟踪，写了一个自己的MyStack包装了一下Java的Stack，贴上代码：

class MyStack{
    private String name;
    private Stack<Integer> data;
    public MyStack(String name){
        this.name=name;
        data=new Stack<>();
    }
    public String getName(){
        return this.name;
    }
    public void push(int data){
        if(!this.data.isEmpty()&&this.data.peek()<data){
            System.out.println("出错");
        }
        this.data.push(data);
    }
    public int peek(){
        return data.peek();
    }
    public int pop(){
        return data.pop();
    }
    public int size(){
        return data.size();
    }
    public boolean isEmpty(){
        return data.isEmpty();
    }
}

      然后就是Hanoi递推的实现，还是贴上图片

      我们要按照Hanoi的逻辑将原盘从A棒移动到C棒，那么，就必须以B棒作为媒介，
最大的必须在最下面，所以，我们必须把上面4个圆盘先移动到B棒上。
      但是又看，上面4个，要想把第四个移动到B棒，就得用C棒暂时当媒介，先把上面3个移动到C棒，以此类推，知道只有最后一个的时候，就可以直接移动了，所以，我们要做的就是想出一个算法，递推到只剩一个圆盘，然后慢慢回栈，到第二，第三，第四，最后第五。
先贴上代码：

public static void hanoi(int size,MyStack a,MyStack b,MyStack c){
        if(size==1){
            c.push(a.pop());
        }else{
            int n=b.size();
            hanoi(size-1,a,c,b);
            c.push(a.pop());
            hanoi(b.size()-n,b,a,c);
        }
    }

      首先解释参数中的size，因为栈无法在不取出元素的情况下递减长度，所以增加了参数size作为栈的圆盘指针，限定只能移动size个圆盘。

      所以，当size==1的时候，就是只剩下一个圆盘，那么就顺理成章的直接移动到C棒了，不必在意此时的C棒回栈后是B棒还是A棒，那不是此时递归该担心的事情。

      在算法中，如果size！=1，那么说明我们需要一个作为媒介，让size-1个圆盘先暂时放到媒介上，然后将第size个圆盘放过去，所以，我们需要进行一次递归，将第size-1个上面的圆盘重新进行计算该存放的位置，计算完成后，然后放入第size个圆盘到C帮，然后再将媒介B棒中的圆盘又以A棒为媒介，以此方式放入C盘。

      至于为什么要在递归前缓存一次B棒的size，因为进入递归前不知道B棒是否有数据，说不定此次计算正是上一次的递归呢，不知道后面的方法B棒会是怎样的存在，不知道会进入多少次递归，假设B棒在进入第一次递归前长度为2，递归完后，长度为5，第二次递归时，如果不限制size长度，直接使用B棒的size，那么，除了第一次递归时增加的3个数据，还会把原本的2个数据一起计算进去，博主就在这个坑绕了一些时间，最后跟踪了一下才明白这个。

文字有点多，最后贴上完整代码：

public class Hanoi {
    private static int m=1;
    private static MyStack a=new MyStack("A");
    private static MyStack b=new MyStack("B");
    private static MyStack c=new MyStack("C");  
    public static void main(String[] args) {
        for(int i=5;i>0;i--){
            a.push(i);
        }
        hanoi(a.size(),a,b,c);
        print(c);
    }
    public static void hanoi(int size,MyStack a,MyStack b,MyStack c){
        if(size==1){
            System.out.println("第"+m+++"步,从"+a.getName()+"移动了  "+a.peek()+"到了"+c.getName());
            c.push(a.pop());
        }else{
            int n=b.size();
            hanoi(size-1,a,c,b);
            System.out.println("第"+m+++"步,从"+a.getName()+"移动了  "+a.peek()+"到了"+c.getName());
            c.push(a.pop());
            hanoi(b.size()-n,b,a,c);
        }
    }

    public static void print(MyStack temp){
        System.out.println("size:"+temp.size());
        for(int i=0,n=temp.size();i<n;i++){
            System.out.print(temp.pop()+" ");
        }
        System.out.println();
    }
}
class MyStack{
    private String name;
    private Stack<Integer> data;
    public MyStack(String name){
        this.name=name;
        data=new Stack<>();
    }
    public String getName(){
        return this.name;
    }
    public void push(int data){
        if(!this.data.isEmpty()&&this.data.peek()<data){
            System.out.println("出错");
        }
        this.data.push(data);
    }
    public int peek(){
        return data.peek();
    }
    public int pop(){
        return data.pop();
    }
    public int size(){
        return data.size();
    }
    public boolean isEmpty(){
        return data.isEmpty();
    }
}

核心算法只有那一段，其他是我为了方便跟踪增加的，各位在测试的时候可以选择性删除。