干诺塔问题的原理图解及实现

一、汉诺塔问题

   如下图所示，从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数

（1）n == 1

   　　　　　　第1次  1号盘  A---->C       sum = 1 次

(2) n == 2

   　　　　　　第1次  1号盘  A---->B

  　　　　　　 第2次  2号盘  A---->C

   　　　　　　第3次  1号盘  B---->C        sum = 3 次

（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 sum = 7 次
不难发现规律：1个圆盘的次数 2的1次方减1

2个圆盘的次数 2的2次方减1

                         3个圆盘的次数 2的3次方减1

                          。  。   。    。   。 

                        n个圆盘的次数 2的n次方减1

故：移动次数为：2^n - 1

二、调用方法的栈机制

从主线程开始调用方法（函数）不停的进行压栈和出栈操作，函数的调用就是将函数压入栈中，函数的结束就是函数出栈的过程，这样就保证了方法调用的顺序流，即当函数出现多层嵌套时，需要从外到内一层层把函数压入栈中，最后栈顶的函数（最内层的函数）先执行结束后出栈，再倒数第二层的函数执行结束出栈，到最后，第一个进栈的函数调用结束后从栈中弹出回到主线程，并且结束。

三、递归算法分析

递归调用结束点的理解：
这里还必须有一个结束点，或者具体的说是在调用到某一次后函数能返回一个确定的值，接着倒数第二个就能返回一个确定的值，一直到第一次调用的这个函数能返回一个确定的值。
实现这个算法可以简单分为三个步骤：

（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上；

四、python代码

基于算法分析的三个步骤：
（1）move(n - 1, a, c, b)
（2）move(1, a, b, c)
（3）move(n - 1, b, a, c)

def move(n, a, b, c):
    if n == 1:
        print(a, '-->', c)
    else:
        move(n - 1, a, c, b)
        move(1, a, b, c)
        move(n - 1, b, a, c)


# 期待输出:
# A --> C
# A --> B
# C --> B
# A --> C
# B --> A
# B --> C
# A --> C
move(3, 'A', 'B', 'C')