递归
递归
在解决⼀个规模为n的问题时，如果满⾜以下条件，我们可以使⽤递归来解决：
a. 问题可以被划分为规模更⼩的⼦问题，并且这些⼦问题具有与原问题相同的解决⽅法。
b. 当我们知道规模更⼩的⼦问题（规模为 n - 1）的解时，我们可以直接计算出规模为 n 的问题
的解。
c. 存在⼀种简单情况，或者说当问题的规模⾜够⼩时，我们可以直接求解问题。
⼀般的递归求解过程如下：
a. 验证是否满⾜简单情况。
b. 假设较⼩规模的问题已经解决，解决当前问题。
上述步骤可以通过数学归纳法来证明。
汉诺塔 （easy）
题⽬描述：
在经典汉诺塔问题中，有 3 根柱⼦及 N 个不同⼤⼩的穿孔圆盘，盘⼦可以滑⼊任意⼀根柱⼦。⼀开始，所有盘⼦⾃上⽽下按升序依次套在第⼀根柱⼦上(即每⼀个盘⼦只能放在更⼤的盘⼦上⾯)。移动圆盘时受到以下限制:
(1) 每次只能移动⼀个盘⼦;
(2) 盘⼦只能从柱⼦顶端滑出移到下⼀根柱⼦;
(3) 盘⼦只能叠在⽐它⼤的盘⼦上。
请编写程序，⽤栈将所有盘⼦从第⼀根柱⼦移到最后⼀根柱⼦。
你需要原地修改栈。
⽰例1:
输⼊：A = [2, 1, 0], B = [], C = []
输出：C = [2, 1, 0]
⽰例2:
输⼊：A = [1, 0], B = [], C = []
比特就业课
输出：C = [1, 0]
提⽰:
A中盘⼦的数⽬不⼤于14个。
解法（递归）：
算法思路：
这是⼀道递归⽅法的经典题⽬，我们可以先从最简单的情况考虑：
• 假设 n = 1，只有⼀个盘⼦，很简单，直接把它从 A 中拿出来，移到 C 上；
• 如果 n = 2 呢？这时候我们就要借助 B 了，因为⼩盘⼦必须时刻都在⼤盘⼦上⾯，共需要 3 步（为了⽅便叙述，记 A 中的盘⼦从上到下为 1 号，2 号）：
a. 1 号盘⼦放到 B 上；
b. 2 号盘⼦放到 C 上；
c. 1 号盘⼦放到 C 上。
⾄此，C 中的盘⼦从上到下为 1 号， 2 号。
• 如果 n > 2 呢？这是我们需要⽤到 n = 2 时的策略，将 A 上⾯的两个盘⼦挪到 B 上，再将最⼤的盘⼦挪到 C 上，最后将 B 上的⼩盘⼦挪到 C 上就完成了所有步骤。例如 n = 3 时如下图：
因为 A 中最后处理的是最⼤的盘⼦，所以在移动过程中不存在⼤盘⼦在⼩盘⼦上⾯的情况。
则本题可以被解释为：
- 对于规模为 n 的问题，我们需要将 A 柱上的 n 个盘⼦移动到C柱上。
- 规模为 n 的问题可以被拆分为规模为 n-1 的⼦问题：
a. 将 A 柱上的上⾯ n-1 个盘⼦移动到B柱上。
b. 将 A 柱上的最⼤盘⼦移动到 C 柱上，然后将 B 柱上的 n-1 个盘⼦移动到C柱上。 - 当问题的规模变为 n=1 时，即只有⼀个盘⼦时，我们可以直接将其从 A 柱移动到 C 柱
• 需要注意的是，步骤 2.b 考虑的是总体问题中的 ⼦问题b 情况。在处理⼦问题的 ⼦问题b 时，我们应该将 A 柱中的最上⾯的盘⼦移动到 C 柱，然后再将 B 柱上的盘⼦移动到 C 柱。在处理总体问题的 ⼦问题b 时，A 柱中的最⼤盘⼦仍然是最上⾯的盘⼦，因此这种做法是通⽤的。
算法流程：
递归函数设计：void hanotaa(vector& A, vector& B, vector& C, int n)
- 返回值：⽆；
- 参数：三个柱⼦上的盘⼦，当前需要处理的盘⼦个数（当前问题规模）。
- 函数作⽤：将 A 中的上⾯ n 个盘⼦挪到 C 中。
递归函数流程： - 当前问题规模为 n=1 时，直接将 A 中的最上⾯盘⼦挪到 C 中并返回；
- 递归将 A 中最上⾯的 n-1 个盘⼦挪到 B 中；
- 将 A 中最上⾯的⼀个盘⼦挪到 C 中；
- 将 B 中上⾯ n-1 个盘⼦挪到 C 中。
算法代码：
java
class Solution{
public void hanota(List<Integer> a, List<Integer> b, List<Integer> c) {
dfs(a, b, c, a.size());
}
public void dfs(List<Integer> a, List<Integer> b, List<Integer> c, int n){
if(n == 1){
c.add(a.remove(a.size() - 1));
return;
}
dfs(a, c, b, n - 1);
c.add(a.remove(a.size() - 1));
dfs(b, a, c, n - 1);
}
}