二叉树LCA与回溯算法：5道高频面试题解析

王饮刀

1. 面试算法题解析的价值与定位

在技术岗位的招聘流程中，算法与数据结构题目始终是衡量候选人基本功的核心标尺。最近五年内，头部科技企业的面试题库中，约有75%的新增题目来源于经典算法的变体或组合。这组编号36至40的题目，正是从高频考点中提炼出的典型代表，涵盖了二叉树、动态规划、回溯算法等关键知识域。

我曾参与过某一线大厂算法题库的维护工作，发现面试官最看重的并非最终答案的正确性，而是解题过程中展现出的问题拆解能力、边界条件处理意识和时间复杂度优化思路。下面我们就以工程师实战视角，深入剖析这五道题的解题脉络。

2. 题目36：二叉树最近公共祖先

2.1 问题重述

给定二叉树和两个节点p、q，找到它们的最低公共祖先（LCA）。LCA定义为同时是p、q祖先的节点中深度最大的那个，且一个节点可以是自身的祖先。

2.2 解法分析

2.2.1 递归解法

python复制def lowestCommonAncestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left = lowestCommonAncestor(root.left, p, q)
    right = lowestCommonAncestor(root.right, p, q)
    return root if left and right else left or right

时间复杂度：O(n)，每个节点最多访问一次
空间复杂度：O(h)，递归栈深度取决于树高

关键点：递归终止条件包含找到目标节点的情况，利用布尔短路特性简化返回值判断

2.2.2 迭代解法（父指针法）

使用哈希表记录每个节点的父指针
从p节点回溯到根，记录访问路径
从q节点向上查找第一个出现在p路径中的节点

python复制def lowestCommonAncestor(root, p, q):
    stack = [root]
    parent = {root: None}
    
    while p not in parent or q not in parent:
        node = stack.pop()
        if node.left:
            parent[node.left] = node
            stack.append(node.left)
        if node.right:
            parent[node.right] = node
            stack.append(node.right)
    
    ancestors = set()
    while p:
        ancestors.add(p)
        p = parent[p]
    
    while q not in ancestors:
        q = parent[q]
    return q

2.3 边界条件测试用例

p或q就是根节点
p是q的祖先节点
树退化为链表的情况
空树输入处理

3. 题目37：组合总和II

3.1 问题描述

给定候选数组candidates（可能有重复元素）和目标数target，找出所有唯一组合使和为target。每个数字在每个组合中只能使用一次。

3.2 回溯算法实现

python复制def combinationSum2(candidates, target):
    candidates.sort()
    res = []
    
    def backtrack(start, path, remaining):
        if remaining == 0:
            res.append(path.copy())
            return
        for i in range(start, len(candidates)):
            if i > start and candidates[i] == candidates[i-1]:
                continue
            if candidates[i] > remaining:
                break
            path.append(candidates[i])
            backtrack(i+1, path, remaining - candidates[i])
            path.pop()
    
    backtrack(0, [], target)
    return res

3.3 关键优化点

排序预处理：使相同元素相邻，便于去重
剪枝策略：
- 当前元素大于剩余target时终止循环（基于有序性）
- 跳过与前一个元素相同的候选（i > start条件保证至少选一次）
路径记录：使用path.copy()避免引用问题

3.4 复杂度分析

最坏情况O(2^n)，但实际运行时间远小于此，因为：

排序成本O(nlogn)可忽略
剪枝大幅减少无效搜索
去重避免重复计算

4. 题目38：跳跃游戏II

4.1 问题理解

给定非负整数数组，初始位于第一个索引处。数组元素表示该位置可跳跃的最大长度，求到达最后一个位置的最小跳跃次数。

4.2 贪心算法实现

python复制def jump(nums):
    jumps = 0
    current_end = 0
    farthest = 0
    
    for i in range(len(nums)-1):
        farthest = max(farthest, i + nums[i])
        if i == current_end:
            jumps += 1
            current_end = farthest
            if current_end >= len(nums)-1:
                break
    return jumps

4.3 算法正确性证明

不变式保证：在每次跳跃时，farthest记录当前可达最远位置
最优子结构：每次选择能带来最大扩展范围的跳跃点
边界处理：提前终止当到达终点时

4.4 复杂度对比

方法	时间复杂度	空间复杂度
动态规划	O(n^2)	O(n)
广度优先搜索	O(n^2)	O(n)
贪心算法	O(n)	O(1)

5. 题目39：全排列

5.1 标准回溯解法

python复制def permute(nums):
    res = []
    
    def backtrack(path, remaining):
        if not remaining:
            res.append(path.copy())
            return
        for i in range(len(remaining)):
            path.append(remaining[i])
            backtrack(path, remaining[:i] + remaining[i+1:])
            path.pop()
    
    backtrack([], nums)
    return res

5.2 交换法优化

python复制def permute(nums):
    res = []
    
    def backtrack(first=0):
        if first == len(nums):
            res.append(nums.copy())
            return
        for i in range(first, len(nums)):
            nums[first], nums[i] = nums[i], nums[first]
            backtrack(first + 1)
            nums[first], nums[i] = nums[i], nums[first]
    
    backtrack()
    return res

5.3 性能对比

方法	空间消耗	适用场景
路径记录	O(n!)结果空间	需要保留所有排列
交换法	O(1)额外空间	仅需遍历无需存储

6. 题目40：旋转图像

6.1 问题转换

将n×n矩阵顺时针旋转90度，要求原地修改。

6.2 数学规律分解

旋转等价于：

先沿主对角线转置
再水平翻转每一行

python复制def rotate(matrix):
    n = len(matrix)
    # 转置
    for i in range(n):
        for j in range(i, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    # 水平翻转
    for row in matrix:
        row.reverse()