二叉树遍历：从基础到进阶的全面解析-代码聚汇网

二叉树遍历：从基础到进阶的全面解析

本多敏行·2026-08-14·阅读 23 GEO检测（免费）

二叉树遍历深度优先遍历广度优先遍历

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

1. 二叉树遍历基础与核心概念

二叉树作为数据结构中最基础的树形结构之一，在算法面试和实际工程中都有广泛应用。理解其遍历方式是掌握二叉树操作的第一步。二叉树遍历的本质是按照某种顺序访问树中的每个节点，确保每个节点被访问且仅被访问一次。

1.1 二叉树的基本结构

每个二叉树节点通常包含三个部分：存储的数据、指向左子节点的指针和指向右子节点的指针。用Python类可以这样表示：

python复制class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

这种结构看似简单，却能通过不同的遍历方式派生出丰富的应用场景。在实际项目中，我经常遇到需要根据具体问题选择合适的遍历方式的情况。

1.2 遍历方式的分类依据

二叉树的遍历方式主要分为两大类：

深度优先遍历(DFS)：前序、中序、后序遍历
广度优先遍历(BFS)：层序遍历

选择哪种遍历方式取决于我们需要如何处理节点之间的关系。深度优先适合需要探索到树的最深处再回溯的场景，而广度优先则适合按层次处理节点的场景。

提示：在解决实际问题时，我通常会先问自己"需要优先处理子节点还是兄弟节点"，这个问题的答案往往直接决定了应该选择哪种遍历方式。

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

2. 深度优先遍历的实现与特性

深度优先遍历是理解递归思维的最佳教材之一。三种DFS遍历方式的区别仅在于访问节点、遍历左子树、遍历右子树这三者的执行顺序不同。

2.1 前序遍历(Preorder Traversal)

前序遍历的顺序是：根节点→左子树→右子树。这种遍历方式的特点是总是先访问当前节点，再处理其子节点。

递归实现非常直观：

python复制def preorder(root):
    if not root:
        return
    print(root.val)  # 访问根节点
    preorder(root.left)  # 遍历左子树
    preorder(root.right)  # 遍历右子树

迭代实现需要借助栈：

python复制def preorder_iterative(root):
    stack = [root]
    while stack:
        node = stack.pop()
        if node:
            print(node.val)
            stack.append(node.right)  # 右子节点先入栈
            stack.append(node.left)   # 左子节点后入栈

前序遍历的一个典型应用场景是树的序列化。在实际项目中，我曾用前序遍历来实现配置文件的树形结构保存，因为这种顺序可以方便地在反序列化时重建树的结构。

2.2 中序遍历(Inorder Traversal)

中序遍历的顺序是：左子树→根节点→右子树。对二叉搜索树(BST)进行中序遍历会得到一个升序序列。

递归实现：

python复制def inorder(root):
    if not root:
        return
    inorder(root.left)  # 遍历左子树
    print(root.val)     # 访问根节点
    inorder(root.right) # 遍历右子树

迭代实现稍复杂：

python复制def inorder_iterative(root):
    stack = []
    curr = root
    while curr or stack:
        while curr:  # 先到达最左节点
            stack.append(curr)
            curr = curr.left
        curr = stack.pop()
        print(curr.val)
        curr = curr.right

中序遍历在表达式树求值中特别有用。我曾在一个计算器项目中用它来处理运算符优先级——通过构建表达式树并进行中序遍历，可以自然地处理括号和运算顺序。

2.3 后序遍历(Postorder Traversal)

后序遍历的顺序是：左子树→右子树→根节点。这种遍历的特点是先处理所有子节点再处理父节点。

递归实现：

python复制def postorder(root):
    if not root:
        return
    postorder(root.left)  # 遍历左子树
    postorder(root.right) # 遍历右子树
    print(root.val)       # 访问根节点

迭代实现需要技巧：

python复制def postorder_iterative(root):
    stack = []
    last_visited = None
    curr = root
    while curr or stack:
        while curr:
            stack.append(curr)
            curr = curr.left
        peek = stack[-1]
        if peek.right and peek.right != last_visited:
            curr = peek.right
        else:
            last_visited = stack.pop()
            print(last_visited.val)

后序遍历在释放树形结构内存时非常有用，因为它确保了子节点总是先于父节点被处理。在图形学中，后序遍历也常用于场景图的渲染。

3. 层序遍历的实现与应用

层序遍历(Level Order Traversal)按照树的层次，从上到下、从左到右依次访问每个节点。这种遍历方式需要使用队列作为辅助数据结构。

3.1 基本层序遍历实现

python复制from collections import deque

def level_order(root):
    if not root:
        return []
    queue = deque([root])
    result = []
    while queue:
        node = queue.popleft()
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result

这种实现方式会输出一个扁平化的列表，丢失了层级信息。在实际项目中，我们通常需要保留层级结构。

3.2 保留层级信息的层序遍历

python复制def level_order_with_level(root):
    if not root:
        return []
    result = []
    queue = deque([root])
    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

这种实现方式输出的结果是一个二维列表，每个子列表代表一层的节点值。在UI组件树的渲染、组织结构图的展示等场景中，这种保留层级信息的方式非常有用。

3.3 层序遍历的变种与应用

层序遍历可以衍生出许多有用的变种，例如：

锯齿形层序遍历（Zigzag Level Order）：交替改变每层的遍历方向
底层向上的层序遍历：从最底层开始向上遍历
连接同层节点：为每个节点添加指向同层下一个节点的指针

在一个社交网络项目中，我曾用改进的层序遍历来实现好友推荐系统——根据与用户的距离（层数）来推荐不同亲密程度的好友。

4. 遍历算法的进阶技巧与优化

掌握了基本遍历方法后，我们可以进一步探讨一些提高效率和解决特定问题的技巧。

4.1 莫里斯遍历(Morris Traversal)

莫里斯遍历是一种不需要使用栈或递归的遍历方法，它通过临时修改树的结构（完成后会恢复）来实现O(1)空间复杂度的遍历。

以中序莫里斯遍历为例：

python复制def morris_inorder(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

莫里斯遍历虽然节省了空间，但会使得时间复杂度常数因子增大。在内存受限的环境中，这种技术非常有用。我曾经在一个嵌入式设备项目中用它来处理大型配置树的遍历。

4.2 迭代遍历的统一写法

三种深度优先遍历的迭代实现各有特点，但可以使用统一的模板来实现：

python复制def traverse_unified(root, order="pre"):
    result = []
    stack = [(root, False)]
    while stack:
        node, visited = stack.pop()
        if not node:
            continue
        if visited:
            result.append(node.val)
        else:
            if order == "post":
                stack.append((node, True))
                stack.append((node.right, False))
                stack.append((node.left, False))
            elif order == "in":
                stack.append((node.right, False))
                stack.append((node, True))
                stack.append((node.left, False))
            else:  # pre
                stack.append((node.right, False))
                stack.append((node.left, False))
                stack.append((node, True))
    return result

这种统一写法的核心思想是使用一个标记位来记录节点是否已经被访问过。虽然代码看起来更复杂，但一旦掌握，可以轻松实现三种遍历方式的切换。

4.3 并行化遍历优化

对于特别大的树结构，可以考虑并行化遍历。以层序遍历为例，可以同时处理同一层的多个节点：

python复制from concurrent.futures import ThreadPoolExecutor

def parallel_level_order(root, max_workers=4):
    if not root:
        return []
    result = []
    current_level = [root]
    while current_level:
        result.append([node.val for node in current_level])
        next_level = []
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            def process_node(node):
                children = []
                if node.left:
                    children.append(node.left)
                if node.right:
                    children.append(node.right)
                return children
            for children in executor.map(process_node, current_level):
                next_level.extend(children)
        current_level = next_level
    return result

在实际应用中，并行化遍历可以显著提高处理大型树结构的速度，特别是在每个节点的处理比较耗时时。我在一个基因组数据分析项目中就采用了类似的技术。

5. 常见问题与性能考量

在实际项目中使用二叉树遍历时，会遇到各种边界情况和性能问题。以下是几个常见问题及其解决方案。

5.1 栈溢出问题

递归实现的遍历在树非常深时可能导致栈溢出。解决方法包括：

使用迭代实现替代递归
增加递归深度限制（不推荐，只是临时解决方案）
使用尾递归优化（某些语言支持）

在Python中，递归深度默认限制为1000左右，对于平衡二叉树这通常足够，但对于极端不平衡的树（如退化成链表）就可能出现问题。

5.2 处理大型树的策略

当树非常大无法完整放入内存时，可以考虑：

分块加载：只加载当前需要的部分树结构
外部存储：将树存储在数据库中，按需加载节点
流式处理：边遍历边处理，不保留完整遍历结果

我曾经处理过一个文件系统索引项目，其中目录树非常大，采用了类似B+树的方式将树结构存储在数据库中，按需加载节点进行遍历。

5.3 遍历的应用选择指南

不同遍历方式适合不同场景：

前序遍历：复制树结构、序列化、前缀表达式
中序遍历：二叉搜索树排序、中缀表达式
后序遍历：释放内存、计算目录大小、后缀表达式
层序遍历：查找最短路径、社交网络好友推荐、UI组件渲染

经验分享：在解决二叉树问题时，我通常会先画一个小型示例树，手动模拟不同遍历方式的结果，这往往能帮助我快速确定最适合的遍历方法。

5.4 遍历中的状态管理

在复杂遍历场景中，经常需要维护额外状态。例如，在验证二叉搜索树时，需要在中序遍历过程中记录前一个节点的值：

python复制def is_valid_bst(root):
    stack = []
    prev = None
    curr = root
    while curr or stack:
        while curr:
            stack.append(curr)
            curr = curr.left
        curr = stack.pop()
        if prev and prev.val >= curr.val:
            return False
        prev = curr
        curr = curr.right
    return True

这种模式非常常见，掌握它可以帮助解决许多二叉树相关问题。