汉诺塔的递归算法

算法：当只有一个盘子的时候，只需要从将A塔上的一个盘子移到C塔上。

            当A塔上有两个盘子时，先将A塔上的1号盘子（编号从上到下）移动到B塔上，再将A塔上的2号盘子移动的C塔上，最后将B塔上的小盘子移动到C塔上。

            当A塔上有3个盘子时，先将A塔上编号1至2的盘子（共2个）移动到B塔上（需借助C塔），然后将A塔上的3号最大的盘子移动到C塔，最后将B塔上的两个盘子借助A塔移动到C塔上。

           当A塔上有n个盘子时，先将A塔上编号1至n-1的盘子（共n-1个）移动到B塔上（借助C塔），然后将A塔上最大的n号盘子移动到C塔上，最后将B塔上的n-1个盘子借助A塔移动到C塔上。

          综上所述，除了只有一个盘子时不需要借助其他塔外，其余情况均一样（只是事件的复杂程度不一样）。

         

[cpp] view plain copy

 print?

1. #include <stdio.h>  
2. //第一个塔为初始塔，中间的塔为借用塔，最后一个塔为目标塔  
3. int i=1;//记录步数  
4. void move(int n,char from,char to) //将编号为n的盘子由from移动到to  
5. {printf("第%d步:将%d号盘子%c---->%c\n",i++,n,from,to);  
6. }  
7. void hanoi(int n,char from,char denpend_on,char to)//将n个盘子由初始塔移动到目标塔(利用借用塔)  
8. {  
9.     if (n==1)  
10.     move(1,from,to);//只有一个盘子是直接将初塔上的盘子移动到目的地  
11.     else  
12.     {  
13.       hanoi(n-1,from,to,denpend_on);//先将初始塔的前n-1个盘子借助目的塔移动到借用塔上  
14.       move(n,from,to);              //将剩下的一个盘子移动到目的塔上  
15.       hanoi(n-1,denpend_on,from,to);//最后将借用塔上的n-1个盘子移动到目的塔上  
16.     }  
17. }  
18. void main()  
19. {  
20.      printf("请输入盘子的个数:\n");  
21.      int n;  
22.      scanf("%d",&n);  
23.      char x='A',y='B',z='C';  
24.      printf("盘子移动情况如下:\n");  
25.      hanoi(n,x,y,z);  
26. }  

解执行过程

执行过程图: 

3.特点分析

解决问题的关键,忽略小细节,注重大步骤,这就是递归的精华所在. 
解决”三步曲”:

• 1.A柱子把”共n-1”个盘借助C盘移动到B盘,完成一个大过程
• 2.A柱子把剩下的”第n”个盘直接移动到C盘,完成一个大过程
• 3.B柱子上的”共n-1”个盘借助A移动到C盘,又完成一个大过程

这”三步曲”结合递归方法,即可轻松解决问题,以下是给出的详细代码

---

4.详细代码

    /**         * 汉诺塔(唯有递归才能解决的问题):         *         * ABC三个柱子         *          * 1.3个盘片在A柱子(上到下是小盘到大盘)         *          * 2.要求把盘片移动到C柱子         *          * 3.移动过程中,柱子不能出现小盘在下面         *         * 4.需求:请列出移动的过程,还有移动的次数;         *         * 先分析大过程,忽视细节         *          * 1. A柱子的3个盘子,两个盘子肯定借助C移动到B,完成一个大阶段:         *          * 2. 当A柱子的只剩下最大盘子,那么移动到C         *          * 3. B柱子的两个盘借助A移动到C         *          * 解决的关键是记住大的方向         */        public class Demo01 {            private static int moveCount;            public static void main(String[] args) {                getNum(2);            }            private static void getNum(int num) {                char a = 'A';                char b = 'B';                char c = 'C';                moveCount = 0;//计数器                move(num, a, b, c);                System.out.println("moveCount = "+moveCount);//打印移动的步骤            }            /**             *             * @param moveNum             *            移动的个数             * @param a             *            原柱子             * @param b             *            辅助柱             * @param c             *            目标柱子             */            private static void move(int moveNum, char a, char b, char c) {//原->辅助->目标                moveCount++;                // 看图:2.只有一个时,A把("第"n)个移动到C                // 内部: 只有一个时,原柱子->目标柱子                if (moveNum == 1) {                    System.out.println("from # " + a + " move " + moveNum + " to " + c);                } else {                    // 看图: 1.A借C把("共"n-1个)移动到B                    // 内部: 多个:原柱子->辅助柱子                    // C变成辅助,所以排在第二位,B变成目标;                    move(moveNum - 1, a, c, b);                    System.out.println("from - " + a + " move " + moveNum + " to " + c);                    // 看图: 3.B借A把("共"n-1)个移动到C                    // 内部: 多个:辅助柱->目标柱子                    // A是辅助,所以排在第二位置,C变目标;                    move(moveNum - 1, b, a, c);                }            }        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

运行结果:

from  A move 1 to Cfrom  A move 2 to Bfrom  C move 1 to Bfrom  A move 3 to Cfrom  B move 1 to Afrom  B move 2 to Cfrom  A move 1 to CmoveCount = 7

5.总结

汉诺塔,内部的执行过程是相对繁琐的,所以大家只要记住3个步骤就可以轻松解决并容易记住该算法:三个柱子:1.原柱子2.中间柱(辅助)3.目标柱    1.A把"共"n-1个通过C移到B(递归)    2.如果只剩一个:A把"第"n个直接移动到C盘(打印)    3.B在通过A把"共"n-1个移到C(递归)好了,关于汉诺塔的问题就先给大家讲到这里,大家有什么见解请留言相互学习.

四．算法分析（递归算法）：

       我们在利用计算机求汉诺塔问题时，必不可少的一步是对整个实现求解进行算法分析。到目前为止，求解汉诺塔问题最简单的算法还是同过递归来求，至于是什么是递归，递归实现的机制是什么，我们说的简单点就是自己是一个方法或者说是函数，但是在自己这个函数里有调用自己这个函数的语句，而这个调用怎么才能调用结束呢？，这里还必须有一个结束点，或者具体的说是在调用到某一次后函数能返回一个确定的值，接着倒数第二个就能返回一个确定的值，一直到第一次调用的这个函数能返回一个确定的值。

       实现这个算法可以简单分为三个步骤：

　　　　（1）     把n-1个盘子由A 移到 B；

　　　　（2）     把第n个盘子由 A移到 C；

　　　　（3）     把n-1个盘子由B 移到 C；

从这里入手，在加上上面数学问题解法的分析，我们不难发现，移到的步数必定为奇数步：

　　　　（1）中间的一步是把最大的一个盘子由A移到C上去；

　　　　（2）中间一步之上可以看成把A上n-1个盘子通过借助辅助塔（C塔）移到了B上，

　　　　（3）中间一步之下可以看成把B上n-1个盘子通过借助辅助塔（A塔）移到了C上；

五，java源代码：

package demo;/** * 目的：实现汉诺塔问题求解 * 作者：Dmego  时间：2016-10-15 */import java.util.Scanner;public class TowersOfHanoi {    static int m =0;//标记移动次数    //实现移动的函数    public static void move(int disks,char N,char M)    {        System.out.println("第" + (++m) +" 次移动 : " +" 把 "+ disks+" 号圆盘从 " + N +" ->移到->  " + M);    }    //递归实现汉诺塔的函数    public static void hanoi(int n,char A,char B,char C)    {        if(n == 1)//圆盘只有一个时，只需将其从A塔移到C塔            TowersOfHanoi.move(1, A, C);//将编b号为1的圆盘从A移到C        else        {//否则            hanoi(n - 1, A, C, B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助塔            TowersOfHanoi.move(n, A, C);//把A塔上编号为n的圆盘移到C上            hanoi(n - 1, B, A, C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助塔        }    }    public static void main(String[] args) {        Scanner imput = new Scanner(System.in);        char A = 'A';        char B = 'B';        char C = 'C';        System.out.println("******************************************************************************************");        System.out.println("这是汉诺塔问题（把A塔上编号从小号到大号的圆盘从A塔通过B辅助塔移动到C塔上去");        System.out.println("******************************************************************************************");        System.out.print("请输入圆盘的个数：");        int disks = imput.nextInt();        TowersOfHanoi.hanoi(disks, A, B, C);        System.out.println(">>移动了" + m + "次，把A上的圆盘都移动到了C上");        imput.close();    }}