递归和回溯,我折腾了很久才搞明白的几件事

递归这个东西,我第一次学的时候是真能看懂代码,但让自己写就写不出来。后来刷题刷多了,又踩了一堆坑,才慢慢有点感觉。这篇就把我踩过的坑和理解整理一下,主要写给和我一样「看得懂但写不出」的朋友。
代码用 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 个再挪回来

三、回溯:递归加上一个「后悔」的动作
回溯这个词听着玄乎,其实干的事很朴素:走一步,看看行不行,不行就退回来换条路。跟走迷宫做标记一个道理。
它和递归的关系,我的理解是:回溯就是递归的一种用法,只不过多了两个动作——做选择和撤销选择。递归负责往下钻,撤销负责退回来,让同一层的其他分支不被污染。
写回溯题,我习惯先回答四个问题:

  1. 这一步有哪些选择?(选择列表)

  2. 什么情况下这条路不用走了?(约束,也就是剪枝的机会)

  3. 什么时候算找到了一个解?(结束条件)

  4. 选择完之后怎么恢复现场?(撤销)
    这四个问题想清楚了,代码基本就是一个固定的壳子:
    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 True

    def 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 的位置就不再是咒语,而是你刚才纸上做过的动作。模板是推熟了之后的总结,不是起点。
    有问题欢迎评论区交流,尤其是那种「跑起来不报错但结果不对」的案例,贴出来大家一起找找是哪句撤销忘写了。
posted @ 2026-11-21 09:35  jlw9527  阅读(6)  评论(0)    收藏  举报