汉诺塔（苦口婆心版，是真的很详细了）

哪些场景下可以考虑使用递归来解决问题：

1. 一个大问题可以拆分为多个子问题来解决
2. 拆分后的子问题和原问题除了数据规模不一样，解决的思路是完全相同的
3. 存在递归终止条件

写递归代码不要纠结于递归过程，要思考的是如何用递归解决问题。分析出问题的解决思路，能够将规模逐渐减小，还要有相应的递归出口。

以汉诺塔为例

汉诺塔问题是一个经典的问题。汉诺塔（Hanoi Tower），又称河内塔，源于印度一个古老传说。
大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。
大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
并且规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。
问应该如何操作？

先以三个汉诺塔 为例进行讲解，后面逐步分析为什么通过递归就可以巧妙的解决这个问题。
先来看一下三个的汉诺塔：

将三个柱子从左到右依次命名为：A , B , C 。从图中可以看出，是把 A 柱上面的圆盘移动到 C 上，期间，B 柱作为辅助移动，用来存放n - 1个圆盘，也就是上面两个小的圆盘，辅助移动的柱子发挥了巨大作用。

我们分析一下具体过程：

首先从上至下将盘子命名为 1，2，3，最终是将 A 柱上的盘子移动到 C 柱上，以下为具体过程：

核心步骤1：此时 A 柱为源柱，B 柱为目标柱，C 柱为辅助柱，将1，2，即n - 1个圆盘移到了B柱上，C 柱为空，A 柱还剩下一个最大的盘子。

将编号为1的盘子从A -> C
将编号为2的盘子从A -> B
将编号为1的盘子从C -> B

核心步骤2：将最大的盘子移动到了目标柱 C 上

将编号为3的盘子从A -> C

核心步骤3：此时 A 为辅助，C 为目标，将 B 柱上的n - 1个盘子通过 A 最终移动到 C 柱上。

将编号为1的盘子从B -> A
将编号为2的盘子从B -> C
将编号为1的盘子从A -> C

代码：
这里实现是Java，C/C++结构和这个差不多,把hanoiTower()可以想象成函数

class Main{
    public static void main(String[] args) {
        hanoi('A','B','C',3);
    }
    public static void hanoi(char a,char b,char c,int nDisks){
        if(nDisks == 1){
            //只剩一个盘子，将其移动 a -> c
            move(nDisks,a,c);
            return;
        }
        //此时nDisks > 1
        //核心步骤1:先将n - 1个盘子从A -> B,C作为辅助（针对n - 1个盘子而言）
        //move方法都是将a -> c,所以需要调换传入的柱子,然而都是从 a 拿走盘子,所以 a 不要变
        hanoi(a,c,b,nDisks - 1);
        //核心步骤2:此时最大的盘子在A上,C 为空, n - 1个盘子都在 B 上,将最大的盘子移动到目标柱上
        move(nDisks,a,c);
        //核心步骤3:只需将n - 1个盘子再从B -> C, A 作为辅助（针对n - 1个盘子而言）
        //要将n - 1个盘子移动到 C 上,所以 C 不用动,交换其他两个柱子的顺序
        hanoi(b,a,c,nDisks - 1);
    }
    //将编号为n的盘子，从source -> destination
    public static void move(int nDisks, char sourceTower, char destTower) {
        System.out.println("将编号为" + nDisks + "的盘子从" + sourceTower + "移到" + destTower);
    }
}

但是这里为什么就这点代码就可以解决问题呢?

我们可以从一个盘子开始演算,当掌握其内部规律后就可以理解这里的递归是一步步解决汉诺塔问题的.
这里假设都是将盘子从A -> C

一个盘子

当只有一个盘子的时候,执行方法hanoiTower()，直接进入if判断语句时，就调用move()函数将 A 柱上的盘子移动到 C 上，往后就到return语句，返回结束方法。
传入参数为1的结果：

两个盘子

当有两个盘子的时候，执行方法hanoiTower()，不满足条件跳过if判断语句后，调用hanoiTower()方法开始递归，将n - 1个盘子移到 B 柱上，C 柱为辅助，但是由于只有两个盘子，故用不上 C 。

因为要将盘子移到 B 柱上，所以交换了 b 和 c 变量，又由于传入的n - 1 = 1，此时就和传入一个盘子调用hanoiTower()方法一样，不过因为交换了参数，调用move()函数将 A 柱上的盘子移动到 B 上，往后就到return语句返回。

现在已经将n - 1个盘子移到 B 柱上了，最大的盘子还在 A 柱上，调用 move()方法将第 n 个盘子移到 C 上。

往后又调用hanoiTower()方法将 n - 1 个盘子移到 C 柱上，也就是将 B 上的盘子移到 C 上,就和前面将n - 1个盘子移开步骤是类似的，要将盘子全部移动到 C 上，所以传入的参数不变，其他两个就要交换。
传入参数为2的结果：

三个盘子

一个和两个盘子的情况分析了，三个盘子的过程也给出了。整体规律就是如果将盘子从一个柱子移动到另一个柱子，就先需要利用另一个柱子辅助，先将n - 1个盘子暂存到辅助柱上，暂存的过程时，目标柱暂时作为辅助。暂存完毕后，将最大的盘子移动到目标柱上后，再次调用函数递归，将n - 1个盘子移到目标柱上，此过程和暂存过程类似。

所以三个盘子就是先将n - 1 = 2个盘子暂存到辅助柱上，让目标柱作为辅助移动，而两个盘子具体移动过程也给出了，只是三个盘子的递归要深入一些，其内部变量交换要复杂一点，但是不必纠结，因为这就是递归的意义，我们已经将两个盘子的情况推理出来了，其内部具体的移动步骤就交给计算机。

最后将最大的盘子移动到目标柱上，再次调用函数递归将暂存的n - 1个盘子移动到目标柱上，三个盘子的移动就完成了。往后的四个，五个盘子就可以迎刃而解，只是递归深度不一样，但是解决问题的思路没有变,递归出口也没有变。
传入参数为3的结果：

加餐

这里给出将三个盘子从 A -> B的代码,方便加深理解哦

class Main {
    public static void main(String[] args) {
        hanoi('A','B','C',3);
    }
    public static void hanoi(char a,char b,char c,int nDisks){
        if(nDisks == 1){
            //只剩一个盘子，将其移动 a -> b
            move(nDisks,a,b);
            return;
        }
        //此时nDisks > 1
        //核心步骤1:先将n - 1个盘子从A -> C,B作为辅助
        hanoi(a,c,b,nDisks - 1);
        //核心步骤2:此时最大的盘子在A上,B 为空, n - 1个盘子都在 C 上
        move(nDisks,a,b);
        //核心步骤3:只需将n - 1个盘子再从C -> B, A 作为辅助
        hanoi(c,b,a,nDisks - 1);
    }
    //将编号为n的盘子，从source -> destination
    public static void move(int nDisks, char sourceTower, char destTower) {
        System.out.println("将编号为" + nDisks + "的盘子从" + sourceTower + "移到" + destTower);
    }
}

运行结果：