树结构遍历：DFS与BFS算法详解与实战

1. 项目概述：当树结构遇上DFS与BFS

去年在准备算法竞赛时，我花了整整两周时间死磕树形结构的遍历问题。直到某天深夜调试代码时突然顿悟——原来深度优先搜索（DFS）和广度优先搜索（BFS）在树结构中的应用，就像用两种不同的视角观察一棵真实的树：DFS是拿着放大镜沿着树枝一寸寸摸索的园丁，而BFS则是用无人机逐层扫描的测绘师。这种具象化的理解让我在后来的算法学习中势如破竹。

本文将结合二叉树和多叉树的典型场景，通过LeetCode真题和实际工程案例，拆解DFS和BFS在树结构中的核心应用范式。不同于教科书式的理论讲解，我会重点分享那些在凌晨三点的调试中才领悟的实战技巧——比如如何用非递归实现避免栈溢出、层序遍历时怎样标记层级边界等实用经验。

2. 树结构基础与遍历原理

2.1 树结构的本质特征

树作为一种非线性数据结构，其核心在于节点间的层次关系。以文件系统为例：

• 根目录相当于树的root节点
• 子文件夹是内部节点（非叶子节点）
• 文件就是叶子节点
• 绝对路径本质上就是从根到叶子的访问路径

这种结构决定了遍历时必须考虑两种基本策略：

1. 纵向深入：沿着某条路径一直走到尽头（DFS）
2. 横向扩展：先处理完当前层级所有节点再向下（BFS）

2.2 DFS的三种访问顺序

在二叉树中，根据访问根节点的时机不同，DFS可分为三种经典模式：

python复制# 二叉树节点结构示例
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

1. 前序遍历（根-左-右）

python复制def preorder(root):
    if not root: return
    print(root.val)      # 先访问根
    preorder(root.left)  # 再左子树
    preorder(root.right) # 最后右子树

适用场景：复制树结构（需要先创建父节点再处理子节点）

2. 中序遍历（左-根-右）

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

适用场景：二叉搜索树获取有序序列

3. 后序遍历（左-右-根）

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

适用场景：计算子树特性（如节点数）后再处理父节点

调试心得：递归实现虽然简洁，但在处理超深树时容易栈溢出。我在处理一个10万层的JSON解析树时，就不得不改用显式栈的非递归实现。

2.3 BFS的层序遍历范式

BFS通常借助队列实现层级扩散：

python复制from collections import deque

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

关键改进：需要区分层级时，可以记录每层的节点数：

python复制def levelOrderWithLevel(root):
    if not root: return []
    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)
        print(current_level)  # 输出当前层所有节点

3. 算法实战：问题拆解与优化

3.1 LeetCode 104：二叉树的最大深度

DFS解法：

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

时间复杂度：O(n) 每个节点访问一次

BFS解法：

python复制def maxDepth(root):
    if not root: return 0
    queue = deque([(root, 1)])
    while queue:
        node, depth = queue.popleft()
        if node.left: queue.append((node.left, depth+1))
        if node.right: queue.append((node.right, depth+1))
    return depth

优势：可以在发现目标深度时提前终止

3.2 实际工程案例：DOM树事件代理

前端开发中常用的事件委托就是BFS思想的典型应用：

javascript复制document.getElementById('parent').addEventListener('click', (e) => {
    if(e.target.matches('.child')) {
        // 处理子元素点击
    }
});

这比给每个.child元素单独绑定事件更高效，正是利用了事件冒泡的BFS特性。

4. 高阶应用与性能调优

4.1 迭代深化DFS（IDDFS）

结合DFS和BFS优势的混合算法，适用于状态空间未知的场景：

python复制def iddfs(root, max_depth):
    for depth in range(max_depth):
        if dfs(root, depth): 
            return True
    return False

def dfs(node, remaining_depth):
    if remaining_depth == 0: 
        return node.is_target
    for child in node.children:
        if dfs(child, remaining_depth-1):
            return True
    return False

4.2 双向BFS优化

当搜索起点和终点都已知时，从两端同时进行BFS能大幅减少搜索空间：

python复制def bidirectional_bfs(start, end):
    front, back = {start}, {end}
    visited = set()
    while front and back:
        if front & back:  # 存在交集
            return True
        # 总是扩展较小的集合
        if len(front) > len(back):
            front, back = back, front
        next_front = set()
        for node in front:
            for neighbor in node.neighbors:
                if neighbor not in visited:
                    next_front.add(neighbor)
        visited.update(front)
        front = next_front
    return False

5. 避坑指南与调试技巧

1. 栈溢出预防：

   • 递归实现时，二叉树的最大深度不应超过系统栈深度（通常1000-3000层）
   • 改用显式栈的非递归实现：

   python复制def preorder_iterative(root):
       stack, res = [root], []
       while stack:
           node = stack.pop()
           if node:
               res.append(node.val)
               stack.append(node.right)  # 先右后左
               stack.append(node.left)
       return res
   

2. 层级标记技巧：

   • BFS中可以用None作为层级分隔符：

   python复制def levelOrderMark(root):
       queue = deque([root, None])
       while queue:
           node = queue.popleft()
           if node is None:
               print("end of level")
               if queue: queue.append(None)
           else:
               print(node.val)
               if node.left: queue.append(node.left)
               if node.right: queue.append(node.right)
   

3. 访问顺序验证：

   • 对于复杂树结构，建议先用小样本验证遍历顺序
   • 可视化工具推荐：Graphviz生成树形图辅助调试

在实现红黑树删除操作时，我曾因为混淆了DFS的访问顺序导致旋转出错。后来通过给每个节点添加调试输出，终于发现是在处理"双黑"情况时错误地交换了左右子树的处理顺序。这个教训让我明白：在树算法中，操作顺序就是生命线。