递归算法入门：从汉诺塔到调用栈的深度拆解-代码聚汇网

递归算法入门：从汉诺塔到调用栈的深度拆解

一瓶辣酱·2026-09-04·阅读 22 GEO检测（免费）

递归汉诺塔调用栈

|难度：普通|阅读约 27 分钟

你要是去问任何一个学编程的人：哪个题目让你第一次觉得递归“通了”？十有八九会有人提到汉诺塔。我在学数据结构那会儿也是这样，二叉树的递归遍历背得滚瓜烂熟，但一看到 hanoi(n-1, source, auxiliary, target) 这种参数来回倒腾的写法，脑子里的图景就糊了。后来啃完汉诺塔，再回头学归并排序、树的遍历、表达式求值，思路顺了一大截。

这篇文章就把汉诺塔完整拆一遍：从问题描述、递归建模、代码实现到调用栈可视化，再把“递归法将一个整数转换成字符串”“递归二路归并排序”这类同门问题串进来，帮你建立一套能迁移的递归思维。适合刚学完函数、正在入门算法，或者面临专业认证要补递归基础的同学；如果是要带新手，这篇也可以直接当教案用。

1. 汉诺塔这题凭什么拿来讲递归：问题里藏着一套完整套路

1.1 题目本身并不复杂

先认真说一遍规则，因为很多人写着写着跑偏，往往是把题目理解成了“魔改版”。汉诺塔是这样一个经典玩具：有三根柱子，通常叫 A、B、C。A 柱上从小到大叠着 n 个圆盘，大的在下、小的在上。目标是把所有圆盘从 A 柱整体搬到 C 柱，中间可以借助 B 柱，但要遵守两条硬规矩：

一次只能移动一个圆盘，而且必须是某根柱子最顶上的那个盘；
任何时刻，大盘不能压在小盘上面。

这里要额外提醒一句：三根柱子都能当起点、终点、中转，不是说 B 柱只能当辅助。很多初学汉诺塔的人最后代码写乱了，就是因为心里默认“A是起点，B是中转，C是终点”，但真实递归里每一层柱子的角色都在变。理解这一点，比背代码重要得多。

这个游戏最早来源于法国数学家爱德华·卢卡斯在 1883 年提出的谜题，还附带了一个神叨叨的传说：说在一座寺庙里，僧侣们日夜不停移动 64 片金盘，当所有盘子从一根柱子移到另一根柱子，世界就会毁灭。传说是假的，但如果真按一秒移一次来算，64 个盘子需要 2^64 - 1 秒，约等于 5849 亿年，比宇宙目前已知的年龄还要长几十倍。这个数字我觉得特别适合拿来警告初学者：别拿 n=64 去测试自己的程序，机器跑不死，但你能等到怀疑人生。

1.2 递归解决问题的核心思维：你不必指挥每一块积木

学汉诺塔之前，很多人习惯用“过程模拟”的思路想问题：第一步把最小的移到哪，第二步把次小的移到哪…… n 小的时候还能硬推，n 一大马上就崩。递归给出的观察方式完全不一样。它逼你先回答一个问题：假如我已经有一个函数，能把 n-1 个圆盘按照规则从任一根柱子整体搬到另一根柱子，那我能不能借此解决 n 个圆盘的问题？

能。因为第三步非常简单。你要做的只是三件事：

把上面 n-1 个盘子从起点借助目标柱搬到中转柱；
把最底下那个最大的盘子直接搬到目标柱；
把那 n-1 个盘子从中转柱再整体搬到目标柱。

这个思路的精髓，是把“怎么搬 n-1 个盘子”的细节暂时扔给递归去处理，自己只负责拆出当前这一步。刚开始很多人过不了心理关：“我怎么可能放心让一个函数去做那么复杂的事情？”但写递归恰恰需要这种信任，专业点说就是“把子问题的正确性交给递归假设”。这一关过了，后面写归并排序、二叉树遍历的时候你会特别轻松，因为思路是同一个。

1.3 汉诺塔与递归三要素的对应关系

递归函数想写得稳，永远盯住三件事：终止条件、递归调用、状态变化。汉诺塔正好把这三点暴露得清清楚楚。

终止条件：当 n == 1 时，只剩一个盘，直接从 source 移到 target，不需要再借用辅助柱。递归调用：先把 n-1 个盘从 source 移到 auxiliary，再把最大盘从 source 移到 target，最后把 n-1 个盘从 auxiliary 移到 target。状态变化：每次递归调用 n 都减少 1，柱子参数也跟着重新分配角色。三要素缺一不可。很多网上流传的汉诺塔代码，能跑但很难读懂，就是因为缺少“参数角色在每一层如何变化”的交代。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 从手推两个盘子到三层递归树：解法是怎么一步步自然长出来的

2.1 先用最小的规模找到手感

看任何递归题，我都建议先从最小实例开始，不要直接空想 n=64。

n=1 的时候，题目退化到不能再退化：A 柱只有 1 个盘子，直接放到 C 柱，一步完成。

n=2 的时候，A 柱有 1 小 1 大两个盘子。如果想把大的移到 C，就必须先把小的挪走，给它腾地方。于是步骤很自然是这样：

小盘：A → B
大盘：A → C
小盘：B → C

注意，这个过程中 B 柱第一次真正承担了“中转”功能。到了 n=3，仍然可以先沿用这个策略：把上面两个盘子看成一个整体，先搬到 B，再把最大盘搬到 C，最后把 B 上的两个盘子搬到 C。如果自己动手在纸上模拟，会发现 n=3 需要 7 步：

步骤	移动	说明
1	A → C	把 A 最上面的小盘移到 C
2	A → B	把 A 上的中盘移到 B
3	C → B	把小盘从 C 移到 B 的上方
4	A → C	把最大的盘直接移到 C
5	B → A	把中盘从 B 移到 A
6	B → C	把小盘移到 C
7	A → C	把中盘最终移到 C

你会发现，前 3 步完成的是“把 A 柱最上面 2 个盘整体搬到 B”，第 4 步移动最大的盘，后 3 步完成“把 B 柱上 2 个盘整体搬到 C”。整个结构和 n=2 时是一模一样的逻辑，只是规模变了。这就是递归里常说的“大问题拆成小问题，小问题长得和大问题同构”。

2.2 递归树就是这样长出来的

如果逐步展开 n=3 的调用过程，会得到一棵递归树。我习惯用缩进来看它，每一个层级代表一层递归调用：

hanoi(3, A, C, B)
├── hanoi(2, A, B, C)
│ ├── hanoi(1, A, C, B)
│ ├── 移动 A → B
│ └── hanoi(1, C, B, A)
├── 移动 A → C
└── hanoi(2, B, C, A)
├── hanoi(1, B, A, C)
├── 移动 B → C
└── hanoi(1, A, C, B)

看这棵树你会发现一个规律：递归执行的“打印移动”动作并不是按树从上到下的顺序发生的，而是要先把左子树走完，再打印当前节点的移动，再走右子树。这也是初学者最容易懵的地方——代码里明明只有一句 print，为什么执行顺序这么“绕”？

用中序遍历去理解汉诺塔树反而特别贴切：左子树是“把 n-1 个盘搬到中转柱”，当前节点是“把最大盘移到目标柱”，右子树是“把 n-1 个盘从中转柱搬到目标柱”。所以汉诺塔的执行顺序天然是一棵二叉树的中序遍历。看懂这个，你就能看懂整个程序为什么按那种顺序输出。

2.3 递推式才是汉诺塔的“底牌”

除了递归代码，汉诺塔里还有一个数学上的递推关系值得单独拿出来看。设把 n 个盘子从一根柱子移动到另一根柱子需要 T(n) 步，按照刚才的三步拆法：

T(n) = T(n-1) + 1 + T(n-1) = 2T(n-1) + 1

边界是 T(1)=1。这个递推式的解是 T(n)=2^n - 1，和前面 n=3 时 7 步完全对得上，n=2 时 3 步也对得上。

很多算法教材把汉诺塔当作递归入门题，其实它同时是很好的复杂度分析样本。从这个递推式你能直观感受到：递归层数并不是很多，但总操作次数却是指数级增长。这也是为什么汉诺塔只能用来讲“递归结构”，没法用来讲“高效算法”——它本质上就是指数级别的操作，逃不掉的。

3. 代码实现与调用栈剖开看：机器到底执行了什么

3.1 最简洁的 Python 写法长什么样

先给一份可以直接跑的核心代码：

python复制def hanoi(n, source, target, auxiliary):
    if n == 1:
        print(f"{source} -> {target}")
        return
    hanoi(n - 1, source, auxiliary, target)
    print(f"{source} -> {target}")
    hanoi(n - 1, auxiliary, target, source)


if __name__ == "__main__":
    hanoi(3, "A", "C", "B")

运行结果就是 7 行移动步骤：

text复制A -> C
A -> B
C -> B
A -> C
B -> A
B -> C
A -> C

代码非常短，但要注意函数签名里四个参数的含义：第一个是本次要处理的盘子数量，第二个是这次移动的起点，第三个是这次移动的终点，第四个是中转柱。很多资料写的是 hanoi(n, a, b, c)，初学者很容易以为第二、三、四个参数永远代表 A、B、C 三根物理柱子，这是最大的误解来源。

如果你不想要 print 的副作用，想让函数“纯”一点，可以改成返回步骤列表。这个版本我尤其推荐在学习阶段使用，因为可以用它写断言来自动验证结果：

python复制def hanoi_steps(n, source, target, auxiliary):
    if n == 1:
        return [(source, target)]
    steps = []
    steps.extend(hanoi_steps(n - 1, source, auxiliary, target))
    steps.append((source, target))
    steps.extend(hanoi_steps(n - 1, auxiliary, target, source))
    return steps


steps = hanoi_steps(3, "A", "C", "B")
print(len(steps))  # 7
for step in steps:
    print(f"{step[0]} -> {step[1]}")

这个函数式的写法更接近数学归纳法，在后面的单元测试、自动验证里也更方便。我写工程代码时不推荐用 print 版递归做核心逻辑，但学习阶段 print 是很好的观察工具。

3.2 调用栈到底长什么样：一层一层压进去又弹出来

递归之所以不好理解，是因为它建立在调用栈的机制上。每次调用函数，系统都会把当前函数的参数、局部变量和返回位置压入栈；函数执行完，再从栈里弹出，回到调用处继续执行。递归就是同一个函数不停地压栈，直到某个调用满足终止条件，然后一层层往回弹。

拿 hanoi(3, "A", "C", "B") 来说，第一个递归调用会先进入 hanoi(2, "A", "B", "C")。注意这里发生了什么：第二、三、四个参数从原来的 A、C、B 变成了 A、B、C，也就是说，原来的 target（C）在这一层变成了 auxiliary，而原来的 auxiliary（B）变成了这一层的 target。

接着再进入 hanoi(1, "A", "C", "B")，这时 n=1，直接打印“A -> C”，然后函数返回。返回后，hanoi(2) 才执行自己的 print("A -> B")。这就是为什么你看到的第一个输出是 A->C 而不是 A->B。很多初学者以为代码会先执行 print，但实际上在 print 之前，函数会先一头扎进第一次递归，直到最深处才开始还按顺序往回输出。

用一个小工具把递归过程打印出来非常直观。最笨但最好用的方式是加 depth 参数，缩进显示当前层：

python复制def hanoi_debug(n, source, target, auxiliary, depth=0):
    indent = "    " * depth
    print(f"{indent}enter hanoi({n}, {source}, {target}, {auxiliary})")
    if n == 1:
        print(f"{indent}move {source} -> {target}")
        print(f"{indent}return")
        return
    hanoi_debug(n - 1, source, auxiliary, target, depth + 1)
    print(f"{indent}move {source} -> {target}")
    hanoi_debug(n - 1, auxiliary, target, source, depth + 1)
    print(f"{indent}return")

这段调试版代码跑 n=3 时，你能清楚看到每个函数的进入顺序、移动顺序和返回顺序。核心规律是：调用栈的深度等于递归最深的地方，不会因为执行 2^n 次操作而变成 2^n 层。汉诺塔运行总时间是指数级，但栈深度只是线性级——最坏情况下系统同时只保存 n 层调用，不会爆栈。

3.3 复杂度的账要算清楚

很多人会误以为“调用次数多 = 占内存大”，其实要分两个维度看。汉诺塔的时间复杂度是 O(2^n)，因为总的移动操作数接近 2^n；但空间复杂度是 O(n)，因为递归在同一时刻最多压入 n 层调用帧。

Python 默认的递归深度限制通常是 1000。你如果拿 hanoi(1000, ...) 去跑，不会等到它执行完，直接就在递归进入第 1000 层时抛 RecursionError 了。想看大一点的 n，可以把限制调高，但这只是“允许更深的递归”，并不会减少指数爆炸的总操作数。真正想算 n 很大的汉诺塔，能做的也是去算 2^n-1 这个公式，而不是真去跑递归。

所以调试汉诺塔时，我建议 n 控制在 1~10 之间。这个范围既能验证思路正确，又不会让你等到崩溃。如果只是为了看移动结果，n=8 已经完全够用了。

4. 新手最容易踩的坑与对应排查方案

4.1 最常见错误：终止条件写错，导致无限递归

我见过最多的错误是把边界条件写成 if n == 0:，然后函数体里继续递归调用 n-1。如果 n 是正整数，每次减 1，确实会到达 0，所以这不算完全错，但要配合正确的逻辑：当 n==0 时没有盘子需要移动，直接 return，不能再去访问柱子。还有一种更隐蔽的错误是写成了：

python复制if n == 1:
    print(f"{source} -> {target}")
# 这里没有 return！
hanoi(n - 1, source, auxiliary, target)

if 块执行完之后，代码会继续执行后面的递归调用，然后 n 变 0，再往下变负数，永远不会停。最后你会看到 Python 抛 RecursionError: maximum recursion depth exceeded。解决办法很简单：在终止分支里加 return，保证递归一旦到底就直接返回上层，不继续往深处走。

4.2 参数顺序混乱：分不清“物理柱子”和“角色参数”

这是汉诺塔从入门到放弃的头号原因。大家容易把函数的第二个参数记为 A，第三个记为 B，第四个记为 C，然后脑子里固化了“起点是 A，中转是 B，终点是 C”。但实际上在递归调用过程中，同一个物理柱子会在不同层里扮演不同角色。

建议用带语义的名字代替 a、b、c。比如这样写：

python复制def hanoi(n, from_rod, to_rod, aux_rod):
    if n == 1:
        print(f"{from_rod} -> {to_rod}")
        return
    hanoi(n - 1, from_rod, aux_rod, to_rod)
    print(f"{from_rod} -> {to_rod}")
    hanoi(n - 1, aux_rod, to_rod, from_rod)

读代码的时候，你要把函数签名理解成一句话：把 n 个盘子从 from_rod 借助 aux_rod 移动到 to_rod。于是第一次递归就是在说：先把 n-1 个盘子从 from_rod 借助 to_rod 移动到 aux_rod。第二次递归则是：把 n-1 个盘子从 aux_rod 借助 from_rod 移动到 to_rod。这样三个参数的每一次互换都能从语义上检查对错，而不是靠死记“第二次调用要 swap 前两个还是后两个”。

4.3 跑出来步骤不对，怎么快速定位

如果代码能运行但结果不正确，说明递归结构有问题。这时候先不要盯着屏幕焦虑，把 n 改成 3，手工对比输出。如果结果错乱，大概率是终止条件和递归顺序出了问题。

我调试汉诺塔时喜欢写一个“模拟验证器”，用三个列表模拟三根柱子，把每一步都实际执行一遍，检查是否有违规移动。代码不复杂，但对排查很有帮助：

python复制def verify_hanoi(move_steps, n):
    towers = {
        "A": list(range(n, 0, -1)),  # 初始时 A 柱从上到下是 1..n，所以列表里栈顶是 n
        "B": [],
        "C": [],
    }
    for step in move_steps:
        src, dst = step
        if not towers[src]:
            raise RuntimeError(f"{src} 柱是空的，不能从它移动")
        disk = towers[src].pop()
        if towers[dst] and towers[dst][-1] < disk:
            raise RuntimeError(f"违规移动：{disk} 压到了 {towers[dst][-1]} 上面")
        towers[dst].append(disk)
    if len(towers["C"]) != n:
        raise RuntimeError("C 柱没有最终收集所有盘子")
    return True

这个验证思路很通用。你在笔试、机试里一旦对递归结果心里没底，就写一个小验证函数，把步骤列表放进去跑一遍，正确与否立刻见分晓，比人眼盯屏幕可靠多了。

4.4 不要在递归里随便用可变类型做累加

汉诺塔如果返回列表，很容易写出一个“看似正确但结果叠加”的代码。比如有人为了省事，在函数里定义一个全局列表 steps，每次移动都 append，最后直接打印全局列表。这样不是不能跑，但函数被调用第二次时，第一次的历史数据还在，结果就会重叠。

最省心的方式是让函数返回一个新的列表，递归调用之后用 extend 合并，或者改用闭包传入一个累加器。这种“外部状态污染”的坑不只出现在汉诺塔里，任何递归只要涉及结果收集，都会遇到，早点养成返回新结果的习惯，后面做归并排序、全排列时能少踩很多雷。

5. 递归能力迁移：汉诺塔之外的同类经典场景

5.1 递归法将一个整数 n 转换成字符串

汉诺塔里最核心的招数是“先处理 n-1 的子问题，再处理当前元素”，这种模式在“把整数转成字符串”这种看似和塔无关的问题里也能用上。

题目通常是这样：给定一个整数 n，不能用现成的 str()，用递归实现转字符串。比如 1234 要转成 "1234"。如果从高位往低位处理会有点麻烦，因为人类读整数是从最高位开始的，但程序中更容易拿到的是最低位：1234 % 10 = 4。那么可以换个思路：先把 1234 // 10 = 123 递归转成字符串，再把最后一个字符 '4' 拼到末尾。

python复制def int_to_str(n):
    digits = "0123456789"
    if n < 10:
        return digits[n]
    return int_to_str(n // 10) + digits[n % 10]

这里递归调用在拼接操作之前，所以展开过程是：先一直整除到只剩 1，然后从最内层开始返回 "1"，再拼上 "2"，再拼上 "3"，最后拼上 "4"。递归返回的顺序天然保证了字符串是从左到右的。和汉诺塔一样，代码写起来只需要相信递归调用已经能处理 n//10 这个更小的问题。

5.2 递归二路归并排序：分治递归的标准模板

如果汉诺塔是“一个递归里有两个递归调用”的入门代表，那归并排序就是这种模式最重要的工程应用。很多考试和在线判题系统里都会有“用递归实现二路归并排序”的题目，PTA 上也很常见。它的递归结构是：

把数组从中间分成两半；
递归排序左半边；
递归排序右半边；
把左右两个有序数组合并成一个有序数组。

伪代码思路如下：

python复制def merge_sort(arr, left, right):
    if left >= right:
        return
    mid = (left + right) // 2
    merge_sort(arr, left, mid)
    merge_sort(arr, mid + 1, right)
    merge(arr, left, mid, right)

你可以看到，这和汉诺塔的三步结构几乎同源：都是先递归处理子问题，再处理当前层自己的逻辑，最后再递归处理另一个子问题。区别在于汉诺塔里中间那步是一个移动操作，归并排序里中间那步是合并两个有序序列。

很多人在写归并排序时边界容易搞错，到底是 left, mid 还是 left, mid-1，是 mid, right 还是 mid+1, right。这个没有标准答案，关键是一套函数内部要保持同一套边界口径。用左闭右闭 [left, right] 就统一用，用左闭右开 [left, right) 也统一用。这种“递归里状态一致性”的思维，和汉诺塔里“参数角色一致”的道理是相通的。

5.3 在专业认证和竞赛题里怎么识别递归模型

你去看 CSP、PTA 这类认证考试里的递归题，会发现几乎没有人会把“汉诺塔”原题照搬上去，但很多题目骨子里就是递归模型：给你一棵二叉树求高度、求遍历序列；给你一个表达式求值；给你几个字符求全排列。它们共通点是都能描述成“n 的问题 = 处理若干 n-1 的问题 + 处理当前问题”。

遇到新题时，我建议先问自己三个问题：这个问题有没有更小的同构子问题？子问题之间如何组合回原问题？最小规模的终止状态长什么样？如果都能回答出来，递归解法基本就成型了。汉诺塔的价值就是让你练熟这套提问方式，而不是简单记住某一道题的答案。

同样是递归，汉诺塔属于“树形递归”，因为它一层会分裂出两个子调用。整数转字符串属于“线性递归”，一个子调用链走到黑。归并排序是“分治递归”，两个子问题规模各减半。再往后还有“回溯递归”，比如八皇后、数独、全排列，那又是递归更进阶的应用场景。我的建议是跟着这个顺序由浅入深练：n! 和整数转字符串这类线性递归，然后是汉诺塔这类树形递归，接着是归并排序这种分治递归，最后再碰回溯。

5.4 别急着背代码，先背“流程”

我见过很多同学在准备考试时疯狂背汉诺塔模板，背了忘、忘了背，痛不欲生。其实真正应该背下来的不是参数怎么换，而是那三句话：

先把上面 n-1 个盘子从起点搬到中转柱；
再把最下面的大盘子从起点搬到终点；
最后把中转柱上的 n-1 个盘子搬到终点。

只要用中文把这三句话想清楚，代码里的参数顺序是可以自己现场推出来的。第一次递归里“中转柱”在代码里是第三个参数，所以调用时要把第三个参数和第四个参数互换位置；第二次递归里“起点”不再是原来的起点，而是原来的中转柱，所以要把第一个参数和第二个参数做调整。每次现场推导，比背参数可靠得多。

最后再分享一个学习汉诺塔的小技巧

我当年学汉诺塔时有一个“顿悟”瞬间，是拿一个递归可视化的单步调试工具，一行一行看函数调用栈的变化。系统里每压入一层，我就记录一次当前 A、B、C 三根柱子的状态；每弹出一层，再看下一步移动。当我亲眼看到程序在没有我“指挥”的情况下，自动完成了 n=4 的全部 15 步移动时，才真正理解“递归替你干活”是什么意思。

如果你手边没有可视化工具，也可以自己改造代码，在每一步后打印三个柱子的状态。比如用三个列表模拟柱子，调用时把移动前后的状态都打出来。跑一次 n=4，盯着输出看五分钟，比抄十遍代码都管用。

这个专题后面我还会继续写递归在树、回溯、动态规划前的应用。先把汉诺塔吃透，你后面看哪一类的递归都不会再觉得是玄学。说穿了，递归就是一个“把复杂任务甩给下一层函数”的思维工具，而汉诺塔是把这种思维训练到肌肉记忆的最短路径。