二叉树递归算法精解：翻转、对称与最小深度

1. 二叉树基础与递归思想精要

二叉树作为数据结构中的常青树，在算法领域占据着核心地位。这次训练营聚焦的226、101、111三道题目，恰好覆盖了二叉树操作的三个典型场景：结构变换、对称判断和深度计算。理解这些题目背后的递归思想，远比单纯AC更重要。

递归的本质是"自相似性"，就像俄罗斯套娃一样，每个问题都可以分解为更小的同类问题。在二叉树场景中，这种特性表现得尤为明显——每个节点的处理逻辑都可以复用到其左右子节点上。这也是为什么这三道题目都标注了"递归法"，因为递归是最符合二叉树天然结构的解法。

新手常犯的错误是过度关注递归的调用细节，而忽略了递归定义的完整性。实际上，写好递归的关键在于明确三点：终止条件、本级处理、递归调用。

2. 题目226：翻转二叉树的递归解法

2.1 问题本质与递归思路

翻转二叉树看似简单，却是理解递归的绝佳案例。题目要求将每个节点的左右子树互换，最终得到原二叉树的镜像。从递归视角看：

1. 终止条件：当前节点为null时返回
2. 本级处理：交换当前节点的左右子节点
3. 递归调用：对左右子节点分别执行相同操作

这种"先处理当前节点，再处理子树"的模式，正是二叉树前序遍历的典型应用。

2.2 代码实现与时空分析

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

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

2.3 易错点与调试技巧

1. 忘记处理空节点导致NPE
2. 交换顺序错误（应先保存原始引用）
3. 递归调用前未完成交换导致逻辑混乱

调试时可添加打印语句观察递归过程：

python复制print(f"Processing node {root.val}, left={root.left.val if root.left else None}, right={root.right.val if root.right else None}")

3. 题目101：对称二叉树的递归判定

3.1 对称性的递归定义

判断二叉树是否对称，需要比较的不是单个节点的左右子树，而是整棵树的镜像对称。这需要设计双指针递归：

1. 终止条件：
   • 两节点都为空 → 对称
   • 仅一个为空 → 不对称
   • 值不相等 → 不对称
2. 递归比较：
   • 左树的左 vs 右树的右
   • 左树的右 vs 右树的左

3.2 实现细节与优化

python复制def isSymmetric(root):
    def compare(left, right):
        if not left and not right:
            return True
        if not left or not right:
            return False
        return left.val == right.val and \
               compare(left.left, right.right) and \
               compare(left.right, right.left)
    
    return compare(root.left, root.right) if root else True

注意短路求值特性：当发现不对称时立即终止递归。

3.3 常见误判场景

1. 仅比较左右子节点值而忽略子树结构
2. 混淆镜像对称与完全相同的概念
3. 未处理空树特殊情况

可视化检查法：将树水平翻转后应与原树相同

4. 题目111：二叉树最小深度的递归求解

4.1 最小深度的特殊考量

与最大深度不同，最小深度是指到最近叶子节点的路径。这带来两个关键区别：

1. 单侧为空的节点不能直接取min（因为空侧无叶子）
2. 需要显式判断叶子节点（左右皆空）

4.2 递归解法实现

python复制def minDepth(root):
    if not root:
        return 0
    
    left_depth = minDepth(root.left)
    right_depth = minDepth(root.right)
    
    # 处理单侧为空的情况
    if not root.left:
        return right_depth + 1
    if not root.right:
        return left_depth + 1
    
    return min(left_depth, right_depth) + 1

4.3 性能优化与边界处理

1. 提前终止：当发现深度为1时可立即返回
2. 迭代解法可能更高效（BFS）
3. 注意根节点本身就是叶子的情况

实测对比：对于偏斜树，递归解法可能退化为O(n)空间，而BFS保持O(leaf nodes)

5. 递归问题的通用解题框架

5.1 递归三要素模板

1. 终止条件：列出所有递归结束场景
2. 本级处理：当前节点需要完成的工作
3. 递归调用：如何将问题分解为子问题

5.2 二叉树递归的四种经典模式

1. 前序：父→左→右（适合翻转类操作）
2. 中序：左→父→右（BST相关）
3. 后序：左→右→父（需要子树信息时）
4. 双递归：同时处理两个树（对称判断）

5.3 避免递归陷阱的实用技巧

1. 添加深度参数防止栈溢出

python复制def traverse(node, depth=0):
    if depth > 1000:
        raise Exception("Recursion too deep")

2. 记忆化优化重复计算
3. 尾递归优化（Python虽不支持但可模拟）

6. 从这三题看算法面试应答策略

6.1 解题步骤的标准表述

1. 明确问题边界（如空树、单节点等）
2. 给出递归定义（数学归纳法思维）
3. 实现代码并解释关键行
4. 分析时间/空间复杂度
5. 讨论可能的优化方向

6.2 面试中的常见追问

1. 如何改为迭代实现？
2. 如果树很大可能有什么问题？
3. 如何测试你的解法？

6.3 代码实现的规范细节

1. 防御性编程（检查输入）
2. 辅助函数的合理使用
3. 变量命名体现语义
4. 适当的空行与注释

在二叉树递归问题的实践中，我深刻体会到"简单即是美"——最优雅的解法往往来自对问题本质的透彻理解。这三道题目虽然都被标记为"简单"，但要做到bug-free仍然需要扎实的基本功。建议初学者在纸上画出递归调用栈，这对理解执行流程大有裨益。