二叉树层序遍历的Java实现与对比

1. 二叉树层序遍历的两种实现方式

二叉树层序遍历是算法面试中的高频考点，也是理解树结构操作的基础。今天我将分享两种Java实现方式：基于队列的迭代法和基于递归的深度优先搜索法。这两种方法各有特点，适用于不同场景。

1.1 层序遍历的基本概念

层序遍历（Level Order Traversal）是指按照树的层级从上到下、从左到右依次访问每个节点。想象一下，这就像是在读取一本书的目录结构：先看第一章标题，然后是第一章下的第一节、第二节，接着是第二章标题，依此类推。

这种遍历方式在以下场景特别有用：

• 打印树的结构
• 计算树的深度
• 查找特定层级的节点
• 序列化和反序列化二叉树

2. 基于队列的迭代实现

2.1 核心算法解析

迭代法使用队列（Queue）这种先进先出（FIFO）的数据结构来实现层序遍历。基本思路是：

1. 将根节点放入队列
2. 当队列不为空时：
   • 记录当前队列长度（即当前层的节点数）
   • 依次取出这些节点，并将它们的值存入结果列表
   • 将每个节点的左右子节点（如果存在）加入队列
3. 重复上述过程直到队列为空

java复制public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) {
        return res;
    }
    Deque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);
    
    while(!queue.isEmpty()) {
        int len = queue.size();
        List<Integer> levelNodes = new ArrayList<>();
        while(len > 0) {
            TreeNode node = queue.poll();
            levelNodes.add(node.val);
            if(node.left != null) {
                queue.offer(node.left);
            }
            if(node.right != null) {
                queue.offer(node.right);
            }
            len--;
        }
        res.add(levelNodes);
    }
    return res;
}

2.2 实现细节与优化

1. 队列选择：这里使用了ArrayDeque作为队列实现，相比LinkedList有更好的空间局部性和更少的内存开销。在Java中，ArrayDeque通常是实现队列的首选。

2. 层级处理：内层循环通过len变量确保只处理当前层的节点，这是关键点。每次外层循环开始时，队列中只包含当前层的所有节点。

3. 空值检查：在访问左右子节点前进行非空检查，避免将null值加入队列。

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

5. 空间复杂度：O(n)，最坏情况下队列需要存储最后一层的所有节点（对于完全二叉树约为n/2）

提示：在实际面试中，建议明确说明时间和空间复杂度。对于二叉树问题，通常n表示节点总数。

3. 基于递归的DFS实现

3.1 递归算法解析

递归法采用深度优先搜索（DFS）的策略，但通过记录层级信息来实现层序遍历的效果。核心思想是：

1. 从根节点开始递归
2. 维护当前节点的层级信息
3. 根据层级将节点值放入结果列表的对应位置

java复制class Solution {
    List<List<Integer>> res = new ArrayList<>();
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        dfs(root, 0);
        return res;
    }
    
    private void dfs(TreeNode node, int level) {
        if(node == null) {
            return;
        }
        if(res.size() <= level) {
            res.add(new ArrayList<>());
        }
        res.get(level).add(node.val);
        dfs(node.left, level+1);
        dfs(node.right, level+1);
    }
}

3.2 关键点解析

1. 层级控制：通过level参数跟踪当前递归的深度，确保节点值被放入正确的层级列表。

2. 列表初始化：当访问到新层级时（res.size() <= level），需要为该层级初始化一个新的列表。

3. 静态方法限制：注意dfs方法不能声明为static，因为它需要访问实例变量res。这是Java中内部类访问外部类变量的常见问题。

4. 遍历顺序：虽然是DFS，但由于我们按照层级组织结果，最终效果等同于BFS的层序遍历。

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

6. 空间复杂度：O(h)，h为树的高度（递归调用栈的深度）

4. 两种方法的对比与选择

4.1 性能对比

4.2 选择建议

1. 优先使用迭代法：在大多数情况下，迭代法是更安全的选择，特别是当树的深度很大时（避免栈溢出）。

2. 考虑递归法：当代码简洁性更重要，且能确定树不会太深时（如平衡二叉树），递归法更优雅。

3. 特殊场景：如果需要同时进行其他DFS操作，递归法可能更合适，因为它天然支持深度优先的访问顺序。

5. 常见问题与调试技巧

5.1 典型错误排查

1. 队列处理错误：

   • 症状：结果中层级混乱
   • 原因：没有在内层循环前记录队列长度
   • 修复：确保使用int len = queue.size()并在内层循环中递减

2. 空指针异常：

   • 症状：运行时抛出NullPointerException
   • 原因：没有检查节点是否为null就访问其属性
   • 修复：在访问node.left和node.right前进行非空检查

3. 递归栈溢出：

   • 症状：StackOverflowError
   • 原因：树太深导致递归调用栈过深
   • 修复：改用迭代法或增加JVM栈大小（不推荐）

5.2 调试技巧

1. 打印中间结果：在关键步骤打印队列状态或递归层级，帮助理解程序执行流程。

2. 可视化小树：用简单的3层二叉树手动模拟算法执行，验证边界条件。

3. 单元测试：为以下情况编写测试用例：

   • 空树
   • 只有根节点的树
   • 完全二叉树
   • 左斜树/右斜树

6. 扩展与变种问题

掌握了基本层序遍历后，可以尝试解决以下变种问题：

1. 锯齿形层序遍历：奇数层从左到右，偶数层从右到左

   • 解决方案：根据层级决定是否反转当前层列表

2. 层平均值计算：计算每一层节点的平均值

   • 解决方案：在收集每层节点值后计算均值

3. 右视图/左视图：只返回每层最右/最左的节点

   • 解决方案：只记录每层最后一个/第一个节点

4. N叉树的层序遍历：节点可能有多个子节点

   • 解决方案：将左右子节点的处理扩展为遍历所有子节点

在实际开发中，层序遍历的思想还可以应用于：

• 多级菜单的渲染
• 组织架构图的展示
• 游戏中的AI决策树遍历
• 网络爬虫的广度优先抓取策略

理解这些基础算法不仅有助于通过技术面试，更能培养解决复杂问题的思维方式。建议读者动手实现这些算法，并尝试解决相关的LeetCode题目（如102、107、103、199等）来巩固学习效果。