递归与非递归实现汉诺塔

递归的方法

下面的方法表示借助B，把n块从A移到C

1.如果是只有1块，直接从A移到C就可以了

2.如果是大于1块，将n-1块借助C移到B存起来，然后最底下一块移到C，最后再将B上的n-1块借助A移到C

public static void hanTower(int n,char A,char B,char C){
        if(n==1){
            System.out.println(A + "->" + C);
        }
        else{
            hanTower(n-1,A,C,B);
            System.out.println(A + "->" + C);
            hanTower(n-1,B,A,C);
        }
    }

迭代法

迭代法用的是递归的思想，要用到栈来记录需要的操作，这里新建了一个类来记录一次操作。表示把n块从a借助b移到c

public static class MyOperation{
        public int n;
        public char a,b,c;
        public MyOperation(int n,char a,char b,char c){
            this.n = n;
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }

栈的特点是先进后出，这样的话就先把递归的最后一步，B借助A，把n-1块移到C这个操作入栈，然后再把一块从A到C这个操作入栈，最后把将n-1块借助C移到B存起来，然后最底下一块移到C这个操作入栈。然后后处理是先处理栈顶的操作。这样就会使得栈顶的操作不断分解执行完后才会执行下一个操作，和递归的思路是一样的。

 public static void hanTower2(int n,char A,char B,char C){
        if(n==1){
            System.out.println(A + "->" + C);
            return;
        }
        Stack<MyOperation> stack = new Stack<MyOperation>();
        stack.push(new MyOperation(n,A,B,C));
        while(!stack.isEmpty()){
            MyOperation mo = stack.pop();
            if(mo.n==1){
                System.out.println(mo.a + "->" + mo.c);
            }else{
                /**
                 * 根据栈的特点，后处理的先入栈,就是把递归逆过来写。
                 */
                stack.push(new MyOperation(mo.n-1,mo.b,mo.a,mo.c));
                stack.push(new MyOperation(1,mo.a,mo.b,mo.c));
                stack.push(new MyOperation(mo.n-1,mo.a,mo.c,mo.b));
            }
        }
    }