递归和回溯,我折腾了很久才搞明白的几件事
递归这个东西,我第一次学的时候是真能看懂代码,但让自己写就写不出来。后来刷题刷多了,又踩了一堆坑,才慢慢有点感觉。这篇就把我踩过的坑和理解整理一下,主要写给和我一样「看得懂但写不出」的朋友。
代码用 Python 写,逻辑不复杂,换成 C++ 或 Java 也就是换个语法的事。
一、递归到底在干嘛
教科书上说递归是「函数调用自身」,这话没错,但对写代码没什么帮助。我后来真正开窍,是从调用栈的角度看的。
先看个最简单的例子:
def factorial(n):
if n in (0, 1): # 到这就不往下走了
return 1
return n * factorial(n - 1)
factorial(4) 执行的时候,内存里发生的事情是这样的:
factorial(4) 等着 factorial(3) 的结果
factorial(3) 等着 factorial(2) 的结果
factorial(2) 等着 factorial(1) 的结果
factorial(1) 返回 1,触底了
然后一层层往回返:1 传给 factorial(2) 算出 2,2 传给 factorial(3) 算出 6,最后算出 24。
看明白这个图,几件事就自然清楚了:
- 每次调用自己,都会在栈上压一个新的栈帧。每层的局部变量是独立的,factorial(3) 里的 n 和 factorial(2) 里的 n 是两回事。
- 必须有个地方「触底」,也就是基线条件。没有它,栈会一直压下去直到爆掉。
- 每次递归调用,问题的规模得变小,不然永远到不了底。
我早期写递归翻车,基本都是这三个条件缺了一个。尤其是第三个——比如递归的时候忘了传 n - 1 而是传了 n,看起来代码没问题,一跑就 RecursionError,查半天才发现参数传错了。
另外提一句,Python 默认递归深度大概 1000 层,超了直接报错。有人喜欢用 sys.setrecursionlimit(10**6) 硬调,我的建议是能改迭代就改迭代,硬调上限只是把报错往后推。
二、斐波那契:最经典的反面教材
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
这代码漂亮吧?教科书级别的漂亮。然后你跑一下 fib(40),卡住不动了。
原因是这样的:fib(40) 要算 fib(39) 和 fib(38),而 fib(39) 内部又要算一次 fib(38)……fib(38) 就被算了两遍,fib(37) 被算了更多遍。整棵递归树是指数级膨胀的,时间复杂度 O(2ⁿ)。
解法也简单,算过的存起来就行:
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
加了一行装饰器,fib(500) 都秒出。这就是「重叠子问题」的典型症状:递归树长得很大,但里面重复的节点特别多。遇到这种情况优先想记忆化,而不是硬抗。
当然汉诺塔这种就不一样了,它的递归树没有重复节点,每一步都是必要的,该 2ⁿ 步就是 2ⁿ 步,这是问题本身决定的,优化不动:
def hanoi(n, src, aux, dst):
if n == 1:
print(f"{src} -> {dst}")
return
hanoi(n - 1, src, dst, aux) # 上面 n-1 个盘子先挪开
print(f"{src} -> {dst}") # 最大的盘子归位
hanoi(n - 1, aux, src, dst) # 把 n-1 个再挪回来
三、回溯:递归加上一个「后悔」的动作
回溯这个词听着玄乎,其实干的事很朴素:走一步,看看行不行,不行就退回来换条路。跟走迷宫做标记一个道理。
它和递归的关系,我的理解是:回溯就是递归的一种用法,只不过多了两个动作——做选择和撤销选择。递归负责往下钻,撤销负责退回来,让同一层的其他分支不被污染。
写回溯题,我习惯先回答四个问题:
-
这一步有哪些选择?(选择列表)
-
什么情况下这条路不用走了?(约束,也就是剪枝的机会)
-
什么时候算找到了一个解?(结束条件)
-
选择完之后怎么恢复现场?(撤销)
这四个问题想清楚了,代码基本就是一个固定的壳子:
def backtrack(路径, 选择列表):
if 满足结束条件:
记录结果
return
for 选择 in 选择列表:
if 不满足约束:
continue # 剪枝
做选择
backtrack(下一层)
撤销选择 # 关键
下面用几道题把这个壳子填实。
全排列
输入 [1,2,3],输出所有排列。用 used 数组记哪些数已经用过了:
def permute(nums):
res, path = [], []
used = [False] * len(nums)def backtrack():
if len(path) == len(nums):
res.append(path[:]) # 注意这里是拷贝
return
for i in range(len(nums)):
if used[i]:
continue
used[i] = True
path.append(nums[i])
backtrack()
path.pop() # 和 append 成对出现
used[i] = False # 和置 True 成对出现backtrack()
return res
这里有个我亲测翻过车的坑:结果收集的时候写成了 res.append(path)。path 是同一个列表对象,回溯过程中会被 pop 来 pop 去,最后跑完一看,结果里全是空列表。改成 path[:] 就好了。凡是往结果里存可变对象,都要拷贝一份,这个坑我见不止一个人踩。
还有一个检查习惯:「做选择」和「撤销选择」必须成对出现。append 对 pop,used[i] = True 对 used[i] = False。写的时候上下挨着放,一眼就能看出漏没漏。
组合,顺便聊聊剪枝
从 1..n 里选 k 个数,要求组合不能重复。这里的技巧是用一个 start 下标,每层只从它往后选:
def combine(n, k):
res, path = [], []def backtrack(start):
if len(path) == k:
res.append(path[:])
return
for i in range(start, n - (k - len(path)) + 2):
path.append(i)
backtrack(i + 1)
path.pop()backtrack(1)
return res
循环上界那个 n - (k - len(path)) + 2 是剪枝:如果剩下的数不够凑满 k 个了,后面的循环就别跑了。举个具体例子,n=4、k=2、path 为空的时候,i 最多到 3——选了 4 的话手里只剩 0 个数,必然凑不出两个。这个剪枝对正确性没影响,纯粹是省时间,但组合类题目规模一大,有没有这个剪枝就是能跑和超时的区别。
剪枝这个事,我的经验是先把不剪枝的版本写对,再回头加剪枝。一上来就想着各种优化,很容易把逻辑写乱。
N 皇后
放 n 个皇后到 n×n 棋盘,互相不能攻击。逐行放,每层递归只决定「这一行的皇后放哪一列」:
def solve_n_queens(n):
res = []
path = [] # path[row] = col,第 row 行的皇后放在第 col 列def is_valid(row, col):
for r, c in enumerate(path):
if c == col or abs(r - row) == abs(c - col):
return False # 同列,或者同一条斜线
return Truedef backtrack(row):
if row == n:
res.append(path[:])
return
for col in range(n):
if not is_valid(row, col):
continue
path.append(col)
backtrack(row + 1)
path.pop()backtrack(0)
return res
斜线的判断值得一提:两个点行差等于列差,就在同一条斜线上,所以 abs(r - row) == abs(c - col) 一个式子管两个方向,不用分主对角线副对角线写两遍。
这个版本 is_valid 是 O(n) 的,n 到十几的时候开始吃力。优化方法是拿三个集合分别记录已占用的列、主斜线、副斜线,判断降成 O(1)。主斜线上 row - col 是常数,副斜线上 row + col 是常数,用这个当集合的 key 就行。
数独的思路和 N 皇后完全一样,无非是把「这一行放哪」换成「这个空格填几」,再用行、列、宫三个集合做约束。篇幅原因就不贴完整代码了,套路完全一致,很适合拿来练手。
四、复杂度,以及怎么面对指数级
回溯题的时间复杂度基本都是指数级的:全排列是 n! 量级,N 皇后没有多项式上界。这不是你写得烂,是问题本身的解空间就这么大——你要枚举所有解,输出就有这么大。
所以对回溯题的期待要摆正:目标是把搜索树剪到只含必要分支,而不是指望它变成多项式。具体几招:
- 可行性剪枝:这条路注定走不通,提前掉头(组合题里的上界计算就是这类)。
- 记忆化:递归树里有大量重复节点的时候用,本质是从回溯滑向动态规划。
- 状态压缩:用集合、位运算代替数组遍历,把每一步的判断变快。
递归本身的额外开销是栈空间,深度 O(n)。深度太大怕爆栈就手写一个栈改成迭代,逻辑不变,只是把系统帮你压栈改成自己压。
五、 debugging 递归的一点土办法
递归代码难调,是因为断点打进去一层套一层,很快人就晕了。我常用的两个笨办法:
一、打印带缩进的路径。 在 backtrack 开头加一行:
print(" " * depth, path)
depth 就是递归深度。跑小规模输入(比如 n=3),输出直接就是一棵缩进形式的递归树,哪一层做了什么选择、什么时候撤销的,一目了然。大部分「结果不对」的问题,盯着这棵树看两分钟就能定位。
二、把 n 调到最小再人脑模拟。 n=3 能跑对再试 n=4。直接上大规模输入,出错了你根本看不出是哪步开始歪的。
六、写在最后
把这几年的理解压成三句话:
- 递归的核心是「问题规模必须收缩」,盯住基线条件和参数变化。
- 回溯 = 递归 + 撤销,做选择 和 撤销选择 必须成对出现,存结果必须拷贝。
- 剪枝解决「搜得慢」,记忆化解决「算得重复」,两者不冲突但解决的问题不同。
真要说学习路径,我的建议是别上来就背模板。先手推一遍 n=3 的全排列递归树,把每层 path 的变化写出来,再回头看代码,那些 append/pop 的位置就不再是咒语,而是你刚才纸上做过的动作。模板是推熟了之后的总结,不是起点。
有问题欢迎评论区交流,尤其是那种「跑起来不报错但结果不对」的案例,贴出来大家一起找找是哪句撤销忘写了。

浙公网安备 33010602011771号