对称二叉树判断：递归与迭代解法详解

1. 对称二叉树问题解析

今天咱们来聊聊LeetCode第100题和第39题中关于对称二叉树的解法。对称二叉树判断是数据结构与算法面试中的高频考点，无论是大厂技术面还是日常编程练习，这都是必须掌握的硬核技能。

对称二叉树的定义很简单：一棵二叉树如果和它的镜像完全相同，那么它就是对称的。举个例子，就像照镜子一样，左右两边要完全对称。但要在代码中实现这个判断，可就没看起来那么简单了。

2. 递归解法详解

2.1 递归思路拆解

递归是解决树类问题的经典方法。对于对称二叉树的判断，我们可以这样思考：

• 空树是对称的
• 单节点树也是对称的
• 对于非空树，需要满足：
  1. 左右子树根节点值相同
  2. 左子树的左子树和右子树的右子树对称
  3. 左子树的右子树和右子树的左子树对称

这种"镜像对称"的特性天然适合用递归来解决。我们可以定义一个辅助函数，同时传入左右两个子树进行比较。

2.2 递归实现代码

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

def compare(left, right):
    # 两个节点都为空
    if not left and not right:
        return True
    # 只有一个节点为空
    if not left or not right:
        return False
    # 节点值不相等
    if left.val != right.val:
        return False
    # 递归比较外侧和内侧
    return compare(left.left, right.right) and compare(left.right, right.left)

2.3 递归复杂度分析

时间复杂度：O(n)，需要遍历所有节点
空间复杂度：O(h)，h为树的高度，递归调用栈的深度

提示：递归解法虽然简洁，但在处理极大树时可能会遇到栈溢出问题，这是需要注意的。

3. 迭代解法详解

3.1 迭代思路解析

迭代法通常使用队列或栈来模拟递归过程。对于对称二叉树判断，我们可以使用队列来成对存储需要比较的节点：

1. 初始时将左右子节点入队
2. 每次取出两个节点比较
3. 将左节点的左子节点和右节点的右子节点入队
4. 将左节点的右子节点和右节点的左子节点入队
5. 重复直到队列为空

这种方法更符合"广度优先"的遍历方式，避免了递归的栈溢出风险。

3.2 迭代实现代码

python复制from collections import deque

def isSymmetric(root):
    if not root:
        return True
    
    queue = deque()
    queue.append(root.left)
    queue.append(root.right)
    
    while queue:
        left = queue.popleft()
        right = queue.popleft()
        
        if not left and not right:
            continue
        if not left or not right:
            return False
        if left.val != right.val:
            return False
            
        queue.append(left.left)
        queue.append(right.right)
        queue.append(left.right)
        queue.append(right.left)
    
    return True

3.3 迭代复杂度分析

时间复杂度：O(n)，同样需要遍历所有节点
空间复杂度：O(n)，最坏情况下需要存储所有叶子节点

4. 两种解法的对比与选择

4.1 适用场景分析

递归解法：

• 代码简洁，逻辑清晰
• 适合树深度不大的情况
• 面试中更常被要求实现

迭代解法：

• 不会出现栈溢出
• 适合处理深度很大的树
• 更符合工程实践需求

4.2 性能对比

对于平衡二叉树：

• 递归的空间复杂度是O(log n)
• 迭代的空间复杂度是O(n)

对于退化为链表的树：

• 递归的空间复杂度是O(n)
• 迭代的空间复杂度也是O(n)

5. 常见错误与调试技巧

5.1 典型错误案例

1. 忽略空树情况：

python复制# 错误示例
def isSymmetric(root):
    return compare(root.left, root.right)  # 没有判空

2. 比较顺序错误：

python复制# 错误示例
return compare(left.left, right.left) and compare(left.right, right.right)  # 比较顺序不对

3. 值比较遗漏：

python复制# 错误示例
if left and right:  # 忘记比较节点值
    return compare(left.left, right.right) and compare(left.right, right.left)

5.2 调试技巧

1. 可视化测试用例：

• 画出简单的二叉树结构
• 手动判断是否对称
• 用这个树测试代码

2. 打印调试：

python复制def compare(left, right):
    print(f"Comparing {left.val if left else None} and {right.val if right else None}")
    # ...

3. 边界测试：

• 空树
• 单节点树
• 完全对称树
• 完全不对称树
• 部分对称树

6. 算法优化与变种

6.1 内存优化版本

对于迭代解法，可以优化队列的实现方式：

python复制# 使用列表模拟队列
queue = []
queue.append(root.left)
queue.append(root.right)
while queue:
    left = queue.pop(0)  # 注意这里效率较低
    right = queue.pop(0)
    # ...

注意：Python中list.pop(0)是O(n)操作，对于大数推荐使用collections.deque

6.2 并行处理优化

对于超大树，可以考虑并行处理左右子树的比较，但实现复杂度较高，通常不建议。

6.3 相似问题变种

1. 判断两棵树是否相同（LeetCode 100）
2. 判断子树（LeetCode 572）
3. 翻转二叉树（LeetCode 226）

7. 实际应用场景

对称二叉树算法虽然看似简单，但其思想在以下场景有广泛应用：

1. 文件系统比对：检查目录结构是否对称
2. 图像处理：检测对称图案
3. 编译器设计：语法树对称性检查
4. 游戏开发：场景对称性验证

8. 面试技巧与注意事项

8.1 面试常见问题

1. 能否解释递归解法的时间复杂度？
2. 如何处理超大树避免栈溢出？
3. 能否不用额外空间实现？（Morris遍历变种）
4. 如何修改算法返回不对称的位置？

8.2 回答策略

1. 先给出递归解法，解释思路
2. 主动提出迭代解法，比较优劣
3. 讨论边界条件和异常处理
4. 根据面试官引导深入探讨

8.3 代码书写规范

1. 函数和变量命名清晰
2. 适当添加注释
3. 先处理边界条件
4. 保持代码整洁

9. 扩展练习建议

为了真正掌握这个算法，建议尝试以下练习：

1. 实现Morris遍历版的对称判断
2. 修改算法返回第一个不对称的节点对
3. 实现多叉树的对称判断
4. 将递归改为尾递归形式

10. 个人实战经验分享

在实际编码和面试中，我发现这些技巧特别有用：

1. 先画图再编码：画出几个测试用例的树结构，手动判断对称性，再写代码验证
2. 双指针法：想象两个指针在镜像位置遍历，有助于理解递归关系
3. 测试驱动：先写测试用例再实现，确保覆盖所有边界条件
4. 复杂度分析：养成习惯，对每个解法都分析时空复杂度

对于迭代解法，我习惯用队列而不用栈，因为更符合层次遍历的直觉。同时，入队顺序一定要严格对应镜像位置，这是最容易出错的地方。