翻转二叉树：递归与迭代解法全解析-代码聚汇网

翻转二叉树：递归与迭代解法全解析

周传炽·2026-08-16·阅读 23 GEO检测（免费）

翻转二叉树递归算法迭代算法

|难度：普通|阅读约 15 分钟

1. 问题背景与题目解析

翻转二叉树是数据结构与算法中的经典问题，也是力扣（LeetCode）平台hot100高频题库中的第226题。这道题看似简单，却因其巧妙的递归思想和广泛的应用场景，成为检验程序员基础功底的试金石。

我第一次遇到这个问题是在准备技术面试时，当时觉得"翻转二叉树"这个名字听起来有些抽象。实际上，它描述的是一个非常直观的操作：对于二叉树的每个节点，我们只需要交换它的左右子树，就能完成整棵树的翻转。举个例子，如果你有一棵这样的二叉树：

code复制     4
   /   \
  2     7
 / \   / \
1   3 6   9

翻转后会变成：

code复制     4
   /   \
  7     2
 / \   / \
9   6 3   1

这个问题之所以被列入hot100，是因为它完美体现了分治思想（Divide and Conquer）——通过将大问题分解为小问题来解决。在2015年，Homebrew的作者Max Howell曾在推特上吐槽，因为不会在白板上写出翻转二叉树的代码而被谷歌拒绝，这更让此题名声大噪。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 递归解法：最直观的实现方式

2.1 基础递归实现

递归是解决树问题的天然工具，对于翻转二叉树尤其适合。核心思路是：当前节点的左右子树都翻转好后，只需交换这两个子树即可。以下是Python的实现代码：

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

这个实现的时间复杂度是O(n)，因为每个节点都会被访问一次；空间复杂度在最坏情况下（树退化为链表）是O(n)，平均情况下是O(log n)，由递归调用栈的深度决定。

2.2 递归的优化写法

上述代码可以进一步简化为更紧凑的形式：

python复制def invertTree(root):
    if root:
        root.left, root.right = invertTree(root.right), invertTree(root.left)
    return root

虽然更简洁，但这种写法可能会牺牲一些可读性。在实际面试中，建议先写出清晰易懂的版本，如果时间允许再展示这种优化写法。

提示：递归解法虽然简洁，但在处理极大二叉树时可能引发栈溢出。在实际工程中，如果树的深度可能很大，应该考虑使用迭代方法。

3. 迭代解法：避免递归的风险

3.1 广度优先搜索（BFS）实现

迭代法通常使用队列来实现广度优先搜索。思路是：从根节点开始，每次处理一个节点时，先交换它的左右子节点，然后将子节点入队以便后续处理。

python复制from collections import deque

def invertTree(root):
    if not root:
        return None
    
    queue = deque([root])
    while queue:
        node = queue.popleft()
        # 交换当前节点的左右子节点
        node.left, node.right = node.right, node.left
        
        # 将子节点加入队列
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    
    return root

3.2 深度优先搜索（DFS）实现

除了BFS，我们也可以用栈来实现DFS版本的迭代：

python复制def invertTree(root):
    if not root:
        return None
    
    stack = [root]
    while stack:
        node = stack.pop()
        node.left, node.right = node.right, node.left
        
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)
    
    return root

迭代法的时间复杂度同样是O(n)，空间复杂度在最坏情况下也是O(n)，因为需要存储所有节点。

4. 不同语言实现对比

4.1 C++实现

C++版本需要注意指针操作和内存管理：

cpp复制TreeNode* invertTree(TreeNode* root) {
    if (root == nullptr) {
        return nullptr;
    }
    
    TreeNode* left = invertTree(root->left);
    TreeNode* right = invertTree(root->right);
    
    root->left = right;
    root->right = left;
    
    return root;
}

4.2 Java实现

Java版本与Python类似，但需要更严格的类型声明：

java复制public TreeNode invertTree(TreeNode root) {
    if (root == null) {
        return null;
    }
    
    TreeNode left = invertTree(root.left);
    TreeNode right = invertTree(root.right);
    
    root.left = right;
    root.right = left;
    
    return root;
}

4.3 JavaScript实现

JavaScript版本适合前端开发者：

javascript复制function invertTree(root) {
    if (root === null) {
        return null;
    }
    
    const left = invertTree(root.left);
    const right = invertTree(root.right);
    
    root.left = right;
    root.right = left;
    
    return root;
}

5. 常见错误与边界条件

5.1 空树处理

最容易忽略的边界条件是输入为空树（root为null）的情况。所有实现都应该首先检查这一点：

python复制if not root:
    return None

5.2 单节点树

只有一个根节点的树也是需要考虑的边界情况：

code复制    1

翻转后应该保持不变。

5.3 非平衡树

对于极端非平衡树（如退化为链表的情况），递归解法可能会有栈溢出的风险：

code复制    1
     \
      2
       \
        3

5.4 原地修改与返回值

有些开发者可能会困惑是否需要返回新的树。实际上，我们是在原地修改树结构，但为了链式调用方便，通常会返回根节点。

6. 实际应用场景

翻转二叉树看似简单，但在实际开发中有多种应用场景：

镜像处理：在图形学中，可能需要创建物体的镜像表示。
对称性检查：判断二叉树是否对称时，可以先翻转一棵子树再比较。
数据转换：某些特定算法可能需要反转树的结构来处理数据。
面试筛选：作为考察递归思维和树操作能力的经典题目。

7. 算法扩展与变种

7.1 部分翻转

有时我们不需要翻转整棵树，而只需要翻转特定层级的节点。这可以通过在递归或迭代中添加深度参数来实现。

7.2 条件翻转

只在满足某些条件时翻转节点，例如只翻转值为偶数的节点：

python复制def invertTreeIfEven(root):
    if not root:
        return None
    
    if root.val % 2 == 0:
        root.left, root.right = invertTreeIfEven(root.right), invertTreeIfEven(root.left)
    else:
        root.left = invertTreeIfEven(root.left)
        root.right = invertTreeIfEven(root.right)
    
    return root

7.3 序列化与反序列化

翻转后的树可以通过序列化存储或传输。常见的序列化格式包括JSON或特定的字符串表示。

8. 性能优化与测试

8.1 大规模数据测试

对于包含数百万节点的树，递归方法可能会遇到栈溢出问题。这时迭代法是更好的选择。可以生成随机大规模树进行测试：

python复制import random

def generate_large_tree(depth):
    if depth == 0:
        return None
    root = TreeNode(random.randint(1, 100))
    root.left = generate_large_tree(depth - 1)
    root.right = generate_large_tree(depth - 1)
    return root

large_tree = generate_large_tree(20)  # 深度为20的树

8.2 内存使用分析

使用内存分析工具（如Python的memory_profiler）可以比较不同实现的内存消耗：

python复制@profile
def invert_tree_mem(root):
    # 实现代码...

8.3 时间复杂度验证

通过计时不同规模输入的运行时间，可以验证算法的时间复杂度是否符合预期的O(n)。

9. 与其他题目的关联

翻转二叉树与许多其他树问题有密切联系：

对称二叉树（LeetCode 101）：判断二叉树是否对称，可以通过比较原树和翻转后的树来实现。
相同的树（LeetCode 100）：翻转后检查两棵树是否相同。
子树问题（LeetCode 572）：检查一棵树是否是另一棵树的子树，翻转可能是其中的一步操作。

10. 面试技巧与实战建议

在技术面试中遇到这道题时，建议采取以下策略：

先理解题意：明确什么是翻转二叉树，可以画一个简单例子说明。
提出暴力解法：即使看起来简单，也应该先说明最直观的解法（通常是递归）。
分析复杂度：明确时间复杂度和空间复杂度。
考虑优化：讨论迭代解法及其优势。
处理边界：主动提出各种边界条件（空树、单节点等）。
编写测试：可以口头描述如何测试代码的正确性。
关联知识：展示对相关问题的了解，如对称树、树遍历等。

我在实际面试中遇到过这道题的变种，面试官要求不仅要翻转二叉树，还要统计翻转过程中交换的次数。这需要在基本解法上添加计数器：

python复制def invertTreeWithCount(root):
    if not root:
        return (None, 0)
    
    left, cnt_left = invertTreeWithCount(root.left)
    right, cnt_right = invertTreeWithCount(root.right)
    
    root.left, root.right = right, left
    total = cnt_left + cnt_right + 1  # 当前交换计为1次
    
    return (root, total)

这种变种考察的是对基础算法的扩展能力，也是面试中常见的考察方式。