二叉树核心概念、遍历算法与高频面试题解析-代码聚汇网

二叉树核心概念、遍历算法与高频面试题解析

陈紫璇·2026-08-14·阅读 23 GEO检测（免费）

二叉树遍历算法二叉搜索树

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

1. 二叉树基础概念与核心特性

二叉树是每个节点最多有两个子节点的树形结构，这种看似简单的限制却衍生出丰富的特性和应用场景。让我们先明确几个关键概念：根节点（树的起点）、叶子节点（没有子节点的末端节点）、深度（从根到该节点的最长路径长度）、高度（从该节点到叶子节点的最长路径）。这些基础术语是后续讨论的基石。

二叉树的五种基本形态值得注意：空树、只有根节点、根节点+左子树、根节点+右子树、根节点+左右子树。这种形态多样性直接影响着遍历和处理逻辑。特别要强调的是二叉搜索树(BST)的特性——左子节点值小于父节点，右子节点值大于父节点。这个简单的规则使得查找、插入、删除操作的时间复杂度可以控制在O(log n)。

在实际面试和算法竞赛中，完全二叉树和满二叉树是高频考点。完全二叉树指除了最后一层，其他层节点都达到最大数量，且最后一层节点从左向右连续排列。这个特性使得它可以用数组高效存储（父节点i的左子节点在2i，右子节点在2i+1）。而满二叉树则是每个节点要么是叶子节点，要么正好有两个子节点，这类树的叶子节点数总是等于非叶子节点数加1。

提示：理解二叉树的性质时，建议动手画图。比如证明"二叉树的第i层最多有2^(i-1)个节点"这个结论时，画出一棵三层二叉树并逐层计数，比单纯记忆公式更直观。

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

2. 二叉树遍历的六种经典方式

遍历是二叉树算法的基础，主要分为深度优先(DFS)和广度优先(BFS)两大类。深度优先包含前序、中序、后序三种变体，区别在于访问根节点的时机：

前序遍历：根→左→右（适合复制树结构）
中序遍历：左→根→右（BST中得到升序序列）
后序遍历：左→右→根（适合删除树节点）

递归实现这三种遍历非常简洁（以Python为例）：

python复制def preorder(root):
    if root:
        print(root.val)
        preorder(root.left)
        preorder(root.right)

但实际工程中更推荐迭代实现，避免递归深度限制。以前序遍历为例，使用栈的迭代写法：

python复制def preorder(root):
    stack = [root]
    while stack:
        node = stack.pop()
        if node:
            print(node.val)
            stack.append(node.right)  # 右先入栈后处理
            stack.append(node.left)

层次遍历（BFS）则需要队列辅助，逐层处理节点：

python复制from collections import deque
def levelOrder(root):
    q = deque([root])
    while q:
        node = q.popleft()
        if node:
            print(node.val)
            q.append(node.left)
            q.append(node.right)

Morris遍历是无需额外空间的O(1)空间复杂度算法，通过修改叶子节点的指针实现遍历。虽然实际使用较少，但理解它能深化对树结构的认识。

3. 高频算法题解题套路精讲

3.1 路径总和问题

LeetCode 112题要求判断是否存在从根到叶子节点的路径，其节点值之和等于给定目标。这类问题的通用解法是递归减治法：

python复制def hasPathSum(root, target):
    if not root:
        return False
    if not root.left and not root.right:
        return root.val == target
    return (hasPathSum(root.left, target - root.val) or 
            hasPathSum(root.right, target - root.val))

进阶版是记录所有满足条件的路径（LeetCode 113），这时需要维护当前路径：

python复制def pathSum(root, target):
    res = []
    def dfs(node, path, remaining):
        if not node:
            return
        path.append(node.val)
        if not node.left and not node.right and remaining == node.val:
            res.append(list(path))
        dfs(node.left, path, remaining - node.val)
        dfs(node.right, path, remaining - node.val)
        path.pop()
    dfs(root, [], target)
    return res

3.2 最近公共祖先(LCA)

求二叉树中两个节点的最近公共祖先（LeetCode 236）有多种解法。递归法最直观：

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

对于BST，可以利用节点值大小关系优化（LeetCode 235）：

python复制def lowestCommonAncestor(root, p, q):
    while root:
        if root.val > max(p.val, q.val):
            root = root.left
        elif root.val < min(p.val, q.val):
            root = root.right
        else:
            return root

3.3 序列化与反序列化

二叉树的序列化（LeetCode 297）需要考虑紧凑性和可逆性。前序遍历配合特殊符号标记空节点是常用方案：

python复制def serialize(root):
    def dfs(node):
        if node:
            vals.append(str(node.val))
            dfs(node.left)
            dfs(node.right)
        else:
            vals.append('#')
    vals = []
    dfs(root)
    return ' '.join(vals)

def deserialize(data):
    def dfs():
        val = next(vals)
        if val == '#':
            return None
        node = TreeNode(int(val))
        node.left = dfs()
        node.right = dfs()
        return node
    vals = iter(data.split())
    return dfs()

4. 二叉树进阶与变种问题

4.1 平衡二叉树验证

判断二叉树是否高度平衡（LeetCode 110），需要计算子树高度差：

python复制def isBalanced(root):
    def height(node):
        if not node:
            return 0
        left = height(node.left)
        right = height(node.right)
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        return max(left, right) + 1
    return height(root) != -1

4.2 二叉搜索树验证

验证BST的有效性（LeetCode 98）容易出错，关键要理解定义：

python复制def isValidBST(root):
    def validate(node, low=-float('inf'), high=float('inf')):
        if not node:
            return True
        if not (low < node.val < high):
            return False
        return (validate(node.left, low, node.val) and 
                validate(node.right, node.val, high))
    return validate(root)

4.3 从遍历序列重构二叉树

前序+中序构建二叉树（LeetCode 105）是经典问题：

python复制def buildTree(preorder, inorder):
    if not preorder:
        return None
    root_val = preorder[0]
    root = TreeNode(root_val)
    idx = inorder.index(root_val)
    root.left = buildTree(preorder[1:idx+1], inorder[:idx])
    root.right = buildTree(preorder[idx+1:], inorder[idx+1:])
    return root

4.4 二叉树中的最大路径和

LeetCode 124要求计算任意节点到任意节点的最大路径和：

python复制def maxPathSum(root):
    res = -float('inf')
    def dfs(node):
        nonlocal res
        if not node:
            return 0
        left = max(0, dfs(node.left))
        right = max(0, dfs(node.right))
        res = max(res, left + right + node.val)
        return max(left, right) + node.val
    dfs(root)
    return res

5. 工程实践中的优化技巧

5.1 避免递归栈溢出

对于深度极大的树，递归可能导致栈溢出。迭代法更安全，如前序遍历的迭代实现：

python复制def preorderTraversal(root):
    res = []
    stack = []
    curr = root
    while curr or stack:
        while curr:
            res.append(curr.val)
            stack.append(curr)
            curr = curr.left
        curr = stack.pop()
        curr = curr.right
    return res

5.2 线程二叉树

Morris遍历利用空指针实现O(1)空间遍历，适合内存受限环境：

python复制def morrisInorder(root):
    curr = root
    while curr:
        if not curr.left:
            print(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
                print(curr.val)
                curr = curr.right

5.3 测试用例设计

全面的测试用例应包含：

空树
单节点树
完全二叉树
退化成链表的树
随机生成的树
超大深度树（测试性能）

例如使用hypothesis库生成随机测试：

python复制from hypothesis import given
from hypothesis.strategies import lists, integers

@given(lists(integers()))
def test_tree_properties(nums):
    tree = construct_bst(nums)  # 假设的建树函数
    assert is_bst(tree)  # 验证BST属性

6. 常见错误与调试技巧

6.1 指针修改陷阱

在递归中直接修改指针可能失效，正确做法是返回新指针：

python复制# 错误示范
def deleteNode(root, key):
    if root.val == key:
        root = None  # 这不会实际修改父节点的引用

# 正确做法
def deleteNode(root, key):
    if not root:
        return None
    if root.val == key:
        return None  # 通过返回值传递修改
    root.left = deleteNode(root.left, key)
    root.right = deleteNode(root.right, key)
    return root

6.2 变量作用域混淆

在递归中使用类成员变量要格外小心：

python复制class Solution:
    def sumNumbers(self, root):
        self.total = 0  # 类成员变量
        def dfs(node, path_sum):
            if node:
                path_sum = path_sum * 10 + node.val
                if not node.left and not node.right:
                    self.total += path_sum
                dfs(node.left, path_sum)
                dfs(node.right, path_sum)
        dfs(root, 0)
        return self.total

6.3 重复计算优化

使用记忆化减少重复计算，如计算二叉树直径：

python复制def diameterOfBinaryTree(root):
    res = 0
    @lru_cache(None)
    def height(node):
        nonlocal res
        if not node:
            return 0
        left = height(node.left)
        right = height(node.right)
        res = max(res, left + right)
        return max(left, right) + 1
    height(root)
    return res

在二叉树问题调试时，可视化工具非常有用。可以编写简单的打印函数：

python复制def printTree(root, level=0, prefix="Root: "):
    if root:
        print(" " * (level*4) + prefix + str(root.val))
        printTree(root.left, level+1, "L--- ")
        printTree(root.right, level+1, "R--- ")