c#汉诺塔的递归算法与解析

从左到右 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#不太熟悉,试着写写,就有了以下代码:

结合上面的分析,最重要的就是这里的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 的过程.