二叉树递归算法精讲：翻转与深度计算实战

1. 二叉树递归算法精讲：从翻转二叉树到深度计算

作为一名算法工程师，我深知二叉树是数据结构中最基础也最常考的类型。今天要分享的这四道LeetCode题目（226、101、104、111）堪称二叉树递归的"黄金训练场"，涵盖了前序、后序遍历的应用场景，以及深度/高度计算中的各种陷阱。这些题目看似简单，但如果没有真正理解递归的本质，很容易写出看似正确实则漏洞百出的代码。

2. LC 226 - 翻转二叉树：遍历顺序的选择艺术

2.1 问题描述与直观解法

翻转二叉树的问题要求我们将二叉树中每个节点的左右子树进行交换。想象一下把一棵树放在镜子前，镜中的影像就是翻转后的结果。最直观的解法就是递归遍历每个节点，交换其左右子节点。

python复制def invertTree(root):
    if not root:
        return None
    # 交换左右子树
    root.left, root.right = root.right, root.left
    # 递归处理子树
    invertTree(root.left)
    invertTree(root.right)
    return root

这个实现采用了前序遍历（根-左-右）的顺序。我们首先处理当前节点（交换左右子树），然后递归处理左右子树。这种顺序非常符合直觉，就像我们手动翻转时也会先交换最顶层的节点，再逐层向下。

2.2 为什么中序遍历不行？

很多初学者会尝试用中序遍历（左-根-右）来实现翻转，结果发现得到的树并不正确。让我们看看中序遍历的问题出在哪里：

python复制def invertTree_wrong(root):
    if not root:
        return None
    invertTree_wrong(root.left)  # 先处理左子树
    root.left, root.right = root.right, root.left  # 交换
    invertTree_wrong(root.left)  # 注意：此时处理的其实是原来的右子树！
    return root

问题在于：当我们交换完左右子树后，原来的右子树现在变成了左子树。接着我们递归处理"左子树"时，实际上是在处理原来的右子树，导致部分节点被翻转了两次，而有些节点则完全没有被处理。

关键理解：中序遍历在访问根节点前后都会处理左子树，交换操作会打乱原本的遍历顺序。

2.3 后序遍历的实现与比较

后序遍历（左-右-根）也能正确实现翻转：

python复制def invertTree_postorder(root):
    if not root:
        return None
    left = invertTree_postorder(root.left)
    right = invertTree_postorder(root.right)
    root.left, root.right = right, left
    return root

后序遍历先递归处理左右子树，最后交换当前节点的左右子节点。这种方式同样有效，因为子树在交换前已经被正确处理过了。

选择建议：

• 前序：更直观，代码简洁
• 后序：在某些语言中可能更节省栈空间
• 中序：不适合此问题

3. LC 101 - 对称二叉树：镜像递归的思维训练

3.1 对称性的递归定义

判断二叉树是否对称，关键在于理解"镜像对称"的递归定义。一棵树对称意味着：

1. 根节点的左右子树互为镜像
2. 左子树的左子树与右子树的右子树互为镜像
3. 左子树的右子树与右子树的左子树互为镜像

这与简单的"两棵树相同"不同，对称是比较左对右、右对左的关系。

3.2 递归函数的实现细节

我们需要设计一个辅助函数来比较两棵树是否镜像：

python复制def isSymmetric(root):
    if not root:
        return True
    return isMirror(root.left, root.right)

def isMirror(left, right):
    # 两个节点都为空
    if not left and not right:
        return True
    # 只有一个节点为空
    if not left or not right:
        return False
    # 节点值相等且子树满足镜像关系
    return (left.val == right.val and 
            isMirror(left.left, right.right) and 
            isMirror(left.right, right.left))

终止条件的处理是这道题的关键。必须考虑所有可能的空节点组合：

1. 两个节点都为空 → 对称
2. 一个为空一个不为空 → 不对称
3. 两个都不为空 → 比较值并递归检查子树

3.3 常见错误与调试技巧

新手常犯的错误包括：

1. 只检查节点值相等，忽略子树结构
2. 错误地比较左-左和右-右（应该是左-右和右-左）
3. 漏掉某些空节点情况的判断

调试技巧：

• 画出简单的测试用例（如3层完全对称/不对称的树）
• 在递归函数中加入打印语句，观察比较顺序
• 使用LeetCode的可视化工具观察树的实际结构

4. LC 104 - 二叉树的最大深度：后序的经典应用

4.1 深度与高度的概念区分

在二叉树中，深度和高度是两个相关但不同的概念：

• 深度：从根节点到该节点的边数（根节点深度为0）
• 高度：从该节点到最远叶子节点的边数（叶子节点高度为0）

对于根节点来说，它的高度就是整棵树的最大深度。这个观察让我们可以用计算高度的后序方法来求最大深度。

4.2 递归解法与层序遍历对比

后序递归解法：

python复制def maxDepth(root):
    if not root:
        return 0
    left_depth = maxDepth(root.left)
    right_depth = maxDepth(root.right)
    return max(left_depth, right_depth) + 1

这个实现体现了典型的后序思维：先知道左右子树的结果，再计算当前节点的结果。每次递归调用返回的是当前子树的高度，根节点的高度就是整棵树的最大深度。

层序遍历（BFS）解法：

python复制from collections import deque

def maxDepth_bfs(root):
    if not root:
        return 0
    queue = deque([root])
    depth = 0
    while queue:
        depth += 1
        for _ in range(len(queue)):
            node = queue.popleft()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
    return depth

两种方法的比较：

• 递归：代码简洁，空间复杂度O(h)（h为树高）
• BFS：直观，空间复杂度O(w)（w为树的最大宽度）
• 对于极端不平衡的树，递归可能导致栈溢出，BFS则可能消耗更多内存

4.3 前序求深度的替代方案

虽然后序是更自然的解法，但也可以用前序来记录和更新深度：

python复制def maxDepth_preorder(root):
    def helper(node, current_depth):
        nonlocal max_depth
        if not node:
            return
        if current_depth > max_depth:
            max_depth = current_depth
        helper(node.left, current_depth + 1)
        helper(node.right, current_depth + 1)
    
    max_depth = 0
    helper(root, 1)
    return max_depth

这种方法需要维护一个全局的最大深度变量，在遍历过程中不断更新。虽然可行，但不如后序解法简洁。

5. LC 111 - 二叉树的最小深度：陷阱与边界处理

5.1 最小深度的特殊定义

最小深度是指根节点到最近叶子节点的路径长度。这里的关键在于"叶子节点"的定义——左右子节点都为空的节点。这与最大深度的计算有重要区别。

5.2 直接移植最大深度解法的问题

很多初学者会简单地把max换成min：

python复制# 错误解法！
def minDepth_wrong(root):
    if not root:
        return 0
    return min(minDepth_wrong(root.left), minDepth_wrong(root.right)) + 1

这种解法的问题在于：当某子树为空时，它会返回0，导致min选择空子树的路径。但实际上，路径必须到达叶子节点，不能在半路停止。

5.3 正确的递归处理方法

正确的解法需要单独处理子树为空的情况：

python复制def minDepth(root):
    if not root:
        return 0
    # 左子树为空，只能走右子树
    if not root.left:
        return minDepth(root.right) + 1
    # 右子树为空，只能走左子树
    if not root.right:
        return minDepth(root.left) + 1
    # 左右子树都存在，取较小深度
    return min(minDepth(root.left), minDepth(root.right)) + 1

关键点：

1. 如果左子树为空，最小深度取决于右子树
2. 如果右子树为空，最小深度取决于左子树
3. 只有两子树都不空时，才取较小值

5.4 层序遍历的优化解法

对于最小深度问题，层序遍历（BFS）实际上更高效，因为它可以在遇到第一个叶子节点时立即返回：

python复制from collections import deque

def minDepth_bfs(root):
    if not root:
        return 0
    queue = deque([(root, 1)])
    while queue:
        node, depth = queue.popleft()
        if not node.left and not node.right:
            return depth
        if node.left:
            queue.append((node.left, depth + 1))
        if node.right:
            queue.append((node.right, depth + 1))
    return 0

这种方法的时间复杂度在最坏情况下与递归相同，但在平均情况下（特别是最小深度较小时）会更高效。

6. 递归思维的系统性训练方法

通过这四道题目，我们可以总结出二叉树递归的一些核心要点：

6.1 遍历顺序的选择原则

1. 前序（根-左-右）：当需要"自上而下"处理，父节点的信息会影响子节点的处理时使用

   • 例子：翻转二叉树（先交换再递归）
   • 特点：先处理当前节点，再递归子树

2. 后序（左-右-根）：当需要"自下而上"处理，需要子树的信息来计算当前节点时使用

   • 例子：计算高度/深度（需要先知道子树的高度）
   • 特点：先递归处理子树，再处理当前节点

3. 中序（左-根-右）：主要用于二叉搜索树的性质相关操作

   • 在普通二叉树中应用较少
   • 例子：二叉搜索树的中序遍历得到有序序列

6.2 递归函数的参数设计技巧

1. 对称二叉树：需要比较两棵树，因此递归函数接受两个参数
2. 深度计算：只需要处理单个树，但可能需要额外参数记录当前深度
3. 返回值设计：明确递归函数返回什么（通常是子树的结果）

6.3 终止条件的完备性检查

编写递归函数时，必须考虑所有可能的终止条件：

1. 节点为None的情况
2. 到达叶子节点的情况
3. 满足特定条件的情况（如值相等/不等）

漏掉任何终止条件都可能导致无限递归或错误结果。

6.4 从递归到迭代的转换思路

虽然递归解法简洁，但理解对应的迭代实现也很重要：

1. 前序/后序 → 使用栈模拟递归调用
2. 层序 → 使用队列进行BFS
3. 通过显式数据结构管理状态，避免系统栈的限制

7. 二叉树算法的进阶学习路径

掌握了这些基础题目后，可以继续挑战更复杂的二叉树问题：

1. 构造类问题：

   • 从前序和中序遍历序列构造二叉树
   • 将有序数组转换为二叉搜索树

2. 路径和问题：

   • 路径总和（判断是否存在路径和等于目标值）
   • 二叉树中的最大路径和

3. 特殊性质检查：

   • 验证二叉搜索树
   • 平衡二叉树检查

4. 序列化与反序列化：

   • 二叉树的序列化与反序列化

5. 最近公共祖先(LCA)：

   • 二叉树的最近公共祖先
   • 二叉搜索树的最近公共祖先

每类问题都有其独特的递归思维模式，建议按照类型系统性地练习，逐步建立对二叉树问题的直觉。