汉诺塔详解

汉诺塔

描述：

​ 我们有n个不同大小的盘子和三根木桩，一开始所有的盘子都按照大小顺序套在第一个木桩上，最大的盘子在底部，最小的盘子在顶部。我们的目的就是把所有的盘子都移动到第三根木桩上，在必要的时候可以借助第二个木桩。我们每次只能移动一个盘子，但是不能把较大的盘子放在较小的盘子的上面

思路：

​ 这个题是大多数人接触到递归时的第一题，本身这个问题比较难解，非递归的实现很困难，但是我们可以根据计算机的特性，设计一种优雅而又巧妙的解题方案。

​ 整个解题的过程其实只有三步，就像把大象放进冰箱一样

• 一共n个盘子，我们先把上面的n-1个盘子放到第二个木桩上
• 在把第n个盘子放到第三个木桩上
• 在把n-1个盘子从第二个木桩上放到第三个木桩上

​ 这三步看似很平淡，但是我们可以将这三步看成和本题同级别的问题

• 我们的问题是将n个盘子从A移动到C
• 我们第一步中有将n-1个盘子从A移动到B
• 我们第三步中有将n-1个盘子从B移动到C
• 于是我们可以将盘子移动这个过程抽象出来

这样就有了我们递归的思路：

递归Java实现：

/**
 * @result:汉诺塔的递归实现，思想就是有n的砝码在a位置上，通过b位置做辅助，到达c位置
 * */
public void result(int n,char a,char b,char c){
    if(n<1){
        System.out.println("Wrong!!");
    }
    else if(n==1){
        System.out.println(a+"->"+c);
    }else{
        //重点在这里：将n-1个盘子从a移动到b
        result(n-1,a,c,b);
        System.out.println(a+"->"+c);
        //重点在这里：将n-1个盘子从b移动到c
        result(n-1,b,a,c);
    }
}

非递归实现

• 现在还不会~~等我水平高了再填这个坑

• 现在我会了，hhh

思路：

• 模拟函数栈的调用，这里对递归中的函数调用进行模拟，即可得到我们非递归形式的汉诺塔的实现方案

• 我们使用Java语言进行实现，所以先要定义一个类用来保存函数栈中的参数

• 接着就进行模拟即可，具体代码如下：

Java实现：

/**
 * @result2:汉诺塔的非递归实现，具体思路在下面注释中已有
 * */
public void result2(int n,char a,char b,char c){
    /**
     * 我们定义一个类来模拟一个结构体，用来模拟函数栈的调用
     * */
    class Status{
        int n;
        char start,mid,end;
        public Status() {
        }
        public Status(int n, char start, char mid, char end) {
            this.n = n;
            this.start = start;
            this.mid = mid;
            this.end = end;
        }
    }
    //定义一个空栈
    Stack<Status> functionStack = new Stack<>();  
    //传入我们的初始值
    functionStack.push(new Status(n,a,b,c));
    //当栈不为空的时候进行操作
    while(!functionStack.empty()){
        //取出栈顶元素
        Status temp = functionStack.pop();
        //当栈顶元素中，待操作的盘子数量为1时，直接从此状态的start移动到end即可
        if(temp.n==1){
            System.out.println(temp.start+"->"+temp.end);
        }else{
            //如果不是1，我们来模拟栈的调用
            //在执行的时候，我们应该先执行从start位置放到mid位置上，后执行从mid位置上放到end位置上
            //所以在入栈的时候，应该反过来
            functionStack.push(new Status(temp.n-1,temp.mid,temp.start,temp.end));
            functionStack.push(new Status(1,temp.start,temp.mid,temp.end));
            functionStack.push(new Status(temp.n-1,temp.start,temp.end,temp.mid));
        }
    }
}

• 其实这个是基于递归来实现的非递归方案，本质上和递归没什么区别，只不过是形式没有写成递归，把递归的过程写在了明面上而已。哈哈哈
• 就把这个当非递归使吧。

复杂度分析：

• 根据上面算法的基本操作，我们可以清楚的得到移动次数M(n)=M(n-1)+1+M(n-1)
• 另外M(1)=1

于是我们有了以下的递推关系：

我们使用反向替换法解这个递推式

于是我们得知，在经过i次替换以后，得到下面的式子：

因为初始条件是在n=1的情况下成立的，所以必须让i=n-1我们得到下面方程来解的递推式

故得出结论：

我们应该谨慎的使用递归算法，因为它们的简洁可能会掩盖其低效率的事实