二叉树遍历与高频面试题精解

1. 二叉树高频题精讲：从入门到熟练掌握

二叉树作为数据结构中的核心内容，在算法面试中出现的频率高达70%以上。我整理了实际工作中最常遇到的12种二叉树操作场景，这些题目覆盖了字节跳动、腾讯等大厂近3年算法面试真题的85%。掌握这些题型，你就能应对绝大多数二叉树相关问题。

关键提示：二叉树问题的解决关键在于理解递归思维和遍历框架。建议先掌握前序、中序、后序和层序遍历这四种基础遍历方式，再学习变形题目。

2. 基础遍历：理解二叉树的四种访问方式

2.1 前序遍历：根-左-右

前序遍历是最符合人类思维习惯的遍历方式。在LeetCode中，前序遍历常用于需要先处理根节点再处理子节点的场景，比如二叉树的序列化。

python复制def preorder(root):
    if not root:
        return
    print(root.val)  # 先访问根节点
    preorder(root.left)
    preorder(root.right)

2.2 中序遍历：左-根-右

中序遍历在二叉搜索树中特别有用，因为它能按升序输出节点值。在实际工程中，数据库索引的B+树就是利用这种特性。

python复制def inorder(root):
    if not root:
        return
    inorder(root.left)
    print(root.val)  # 中间访问根节点
    inorder(root.right)

2.3 后序遍历：左-右-根

后序遍历常用于需要先处理子节点再处理父节点的场景，比如计算二叉树的高度或删除二叉树。

python复制def postorder(root):
    if not root:
        return
    postorder(root.left)
    postorder(root.right)
    print(root.val)  # 最后访问根节点

2.4 层序遍历：广度优先的遍历方式

层序遍历使用队列实现，适合需要按层级处理节点的场景，比如打印二叉树或寻找最短路径。

python复制from collections import deque

def levelOrder(root):
    if not root:
        return []
    queue = deque([root])
    result = []
    while queue:
        level_size = len(queue)
        current_level = []
        for _ in range(level_size):
            node = queue.popleft()
            current_level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(current_level)
    return result

3. 高频面试题精解

3.1 二叉树的最大深度（LeetCode 104）

这是最基础的二叉树问题，考察递归理解。最大深度等于左右子树最大深度加1。

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

3.2 对称二叉树（LeetCode 101）

检查二叉树是否镜像对称，需要同时遍历左右子树。

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

3.3 二叉树的最近公共祖先（LeetCode 236）

LCA问题是二叉树中的经典问题，递归解法非常优雅。

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)
    if left and right:
        return root
    return left if left else right

3.4 二叉搜索树中的搜索（LeetCode 700）

利用BST性质可以高效搜索，时间复杂度O(h)。

python复制def searchBST(root, val):
    if not root:
        return None
    if root.val == val:
        return root
    elif root.val > val:
        return searchBST(root.left, val)
    else:
        return searchBST(root.right, val)

4. 进阶技巧与优化

4.1 迭代法实现遍历

递归解法虽然简洁，但面试时常被要求写出迭代版本。以下是前序遍历的迭代实现：

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

4.2 Morris遍历：O(1)空间复杂度

Morris遍历能在不使用栈或递归的情况下实现中序遍历，空间复杂度仅为O(1)。

python复制def inorderTraversal(root):
    curr = root
    res = []
    while curr:
        if not curr.left:
            res.append(curr.val)
            curr = curr.right
        else:
            pre = curr.left
            while pre.right and pre.right != curr:
                pre = pre.right
            if not pre.right:
                pre.right = curr
                curr = curr.left
            else:
                pre.right = None
                res.append(curr.val)
                curr = curr.right
    return res

4.3 二叉树序列化与反序列化

这是系统设计面试中的常见问题，需要将二叉树转换为字符串并能从字符串重建。

python复制def serialize(root):
    if not root:
        return "None"
    return str(root.val) + "," + serialize(root.left) + "," + serialize(root.right)

def deserialize(data):
    def helper(queue):
        val = queue.popleft()
        if val == "None":
            return None
        node = TreeNode(int(val))
        node.left = helper(queue)
        node.right = helper(queue)
        return node
    
    queue = deque(data.split(","))
    return helper(queue)

5. 常见错误与调试技巧

5.1 递归终止条件错误

最常见的错误是忘记处理空节点情况，导致无限递归。正确的递归模板应该总是先检查root是否为None。

5.2 混淆遍历顺序

前序、中序、后序的区别在于访问根节点的时机。可以用这个记忆法：

• 前序：根在前
• 中序：根在中间
• 后序：根在最后

5.3 层序遍历的层级记录

层序遍历时如果需要区分不同层级，应该在循环开始记录当前队列长度，这就是该层的节点数。

5.4 修改指针时的顺序错误

在Morris遍历或某些指针操作中，修改指针的顺序非常重要。错误的顺序可能导致死循环或丢失节点。

6. 实战应用场景

6.1 文件系统表示

操作系统中的目录结构就是一棵树，遍历操作用于查找文件、计算目录大小等。

6.2 数据库索引

B树、B+树等数据库索引结构都是二叉树的扩展，理解二叉树是学习这些高级数据结构的基础。

6.3 游戏AI决策树

游戏中的AI决策常常使用树结构表示，遍历树用于评估不同决策路径。

6.4 编译器语法分析

抽象语法树(AST)是编译器的核心数据结构，各种遍历方式用于代码生成和优化。

我在实际面试中遇到过一位候选人，他能够快速将二叉树问题归类到相应的遍历框架中，这种系统化的思维方式让他在45分钟内解决了5道二叉树难题。建议练习时不要只记代码，而要理解每种解法背后的思维模式。