汉诺塔问题解决收集

"汉诺塔"算法-之通俗易懂,简单的原理-java编程

原文地址：http://blog.csdn.net/nzfxx/article/details/51584204

1.初步介绍

   很多朋友向我咨询汉诺塔的执行过程和原理,其实对于汉诺塔问题,如果不采用递归算法,这种问题就会难以解答,那么下面我通过图解和代码统一把过程和原理写出来,并讲解一些技巧,希望能帮组大家完全理解这个过程和原理.

---

2.图解执行过程

执行过程图:

---

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

---

很多朋友还是想让我画出详细的内部图,那么下面我就把完整的代码内部执行流程写出来给大家:

(ps:这里最重要的就是注意参数,考虑内部的时候,不要一直把A就当作原柱子,B当作辅助柱子,C当作目标柱子,而是根据move(n,参数1,参数2,参数3),因为A,C也可以充当辅助柱子,这里固定不变的是:参数1,为原柱子,2为辅助柱,3为目标柱)

---

内部流程图:

---

5.总结

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

汉诺塔的递归算法与解析

原文地址：http://blog.csdn.net/yafei450225664/article/details/8647908

从左到右 A  B  C 柱 大盘子在下, 小盘子在上, 借助B柱将所有盘子从A柱移动到C柱, 期间只有一个原则: 大盘子只能在小盘子的下面.

如果有3个盘子, 大中小号, 越小的越在上面, 从上面给盘子按顺序编号 1(小),2(中),3(大), 后面的原理解析引用这里的编号.

小时候玩过这个游戏, 基本上玩到第7个,第8个就很没有耐心玩了,并且操作的动作都几乎相同觉得无聊.  后来学习编程, 认识到递归, 用递归解决汉诺塔的算法也是我除了简单的排序算法后学习到的第一种算法.

至于递归,简单来说就是方法内部自己调用自己, 同时也一定有一个结束点. 如果对方法调用栈了解的话,其实是很容易理解方法的调用过程的, 就是从主线程开始调用方法进行不停的压栈和出栈操作. 方法的调入就是将方法压入栈中, 方法的结束就是方法出栈的过程, 这样保证了方法调用的顺序流. 如果跟踪递归的调用情况会发现也是如此, 到最后一定是这个方法最后从栈中弹出回到主线程, 并且结束.

栈的特点:先进后出。 比如一个方法 A 自己调用自己, 我用编号区分一下进栈过程:

A -> A(1) -> A(2) -> A(3)

在A(3)时满足某种条件得以退出, 回到 A(2), A(2)结束回到A(1), 再回到A, 出栈过程:

A(3) -> A(2) -> A(1) -> A

对于递归,还有一个形象的认识,就是我小时候家里有一个柜子, 柜子两端都是玻璃, 头伸进柜子看一面镜子,会看到镜子里还有镜子, 然后镜子里还有镜子, 但和递归的特点不同的是这镜子的反射是没有尽头的, 只要眼睛一直能看到底的话.

了解完递归后, 再回头来看如何用递归的方式解决汉诺塔的问题.

案例 1 - 假设只有一个盘子的时候, 盘子数量 N=1

只有一个步骤   将第1个盘子从A移动到C, 为了对比方便我这样来描述这个步骤：

步骤  盘子编号 从柱子移动   移动到柱子

1       1                A               C

案例 2 - 如果有两个盘子, 盘子数量 N = 2

步骤  盘子编号 从柱子移动   移动到柱子

1              1                A               B

2              2                A               C

3              1                B               C

案例 3  - 如果有三个盘子, 盘子数量 N = 3

步骤  盘子编号 从柱子移动   移动到柱子

1                1　　　  A                    C

2                2　　　  A　　　　    B

3                1              C                     B

4                3              A                    C

5                1              B                    A

6                2              B                    C

7                1              A                    C   

如何找出盘子移动的规律 ？

我们要做的最重要的一件事情就是永远要把最底下的一个盘子从 A 移动到 C

看看上面从1个盘子的移动到3个盘子的移动, 在移动记录中,当盘子的编号和盘子数量相同的时候他们的步骤都是从A移动到C (看加粗的部分),其它的步骤对等.

再观察第3个案例中的第 1-3 步 和 第 5-7步

第 1-3 步 目的是从 A 移动到 B   如果我们把 B 当作终点, 那么这里的第 1-3 步理解起来和 第2个案例的三个步骤完全相同, 都是通过一个柱子来移动,和第2个案例比起来在后面加括号来表示

1       1　　　  A           C     ( A -> B)

2       2　　　  A　       B     ( A -> C)

3       1              C           B      ( B -> C)

总结：将盘子B变成C即可.

第 5-7 步 目的是从 B 移动到 C   如果我们把 C 当作终点, 那么这里的 5-7 步理解起来和上面也是一样的, 和第2个案例的三个步骤也完全相同.和第2个案例比起来就是:

5       1       B           A    ( A -> B)

6       2       B           C    ( A- > C)

7       1       A           C    ( B -> C)

总结: 将盘子B变成A即可

根据这个演示可以明确几点规律:

1. 当盘子只有一个的时候,只有一个动作 从 A 移动到 C 即结束.

2. 当有N个盘子的时候, 中间的动作都是从 A 移动到 C, 那么表示最下面的第N个盘子移动完毕

3. 中间动作之上都可以认为是: 从 A 移动到 B

4. 中间动作之下都可以认为是: 从 B 移动到 C

2，3，4 可以表示为

1       1                A               B

2       2                A               C

3       1                B               C

这种结构一直在重复进行,C#不太熟悉,试着写写,就有了以下代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataStructure
{
    class HanoiTower
    {

        public void MoveDisk(int DiskQuantity,string PositionA, string PositionB, string PositionC)
        {  
            // If there's only one disk, then end.
            if (DiskQuantity == 1)
            {
                Console.WriteLine("Move disk from position {0} to {1}.",  PositionA, PositionC);
                // Must return
                return;
            }
            else
            {
                // Step 1 - Change B to C  (A --> B)
                MoveDisk(DiskQuantity - 1, PositionA,PositionC,PositionB);
                // Step 2 - No changes     (A --> C)
                MoveDisk(1, PositionA, PositionB, PositionC);
                // Step 3 - Change B to A  (A --> C)
                MoveDisk(DiskQuantity - 1, PositionB, PositionA, PositionC);
            }
        }

        static void Main(string[] args)
        {
            HanoiTower hanoi = new HanoiTower();

            Console.WriteLine("Please input Disk Quantity:");
            int DiskQuantity = Convert.ToInt32(Console.ReadLine());

            hanoi.MoveDisk(DiskQuantity, "A", "B", "C");

            Console.ReadKey();
        }
    }
}

 

结合上面的分析,最重要的就是这里的3步交换动作, 中间从 A到C的动作是最底层盘子的最终操作.

 // Step 1 - Change B to C  (A --> B)
 MoveDisk(DiskQuantity - 1, PositionA,PositionC,PositionB);
 // Step 2 - No changes     (A --> C)
 MoveDisk(1, PositionA, PositionB, PositionC);
 // Step 3 - Change B to A  (A --> C)
 MoveDisk(DiskQuantity - 1, PositionB, PositionA, PositionC);
 至于第1个参数为什么是DiskQuantity - 1,或者1 大家再回到上面看看是不是所有的步骤都是.. 1.     1,2,1.    1,2,1,3,1,2,1 这种以盘子数对称的结构,而它前后都是重复1,2,1 的过程.