java代码如何用队列实现层次遍历 java代码队列应用的基础编写教程

爱谁谁

发布时间：2025-08-13 22:45:01

363人浏览过

来源于php中文网

原创

层次遍历使用队列是因为其fifo特性确保按层访问节点，java中通过queue接口（如linkedlist）实现，核心是每层处理前记录队列大小以分离层级，适用于树遍历、bfs、任务调度、消息队列等场景，需注意内存消耗、线程安全、空值处理、性能选择及资源泄漏等问题，正确使用可有效支持并发与解耦设计。

java代码如何用队列实现层次遍历 java代码队列应用的基础编写教程

说起层次遍历，也就是我们常说的广度优先搜索（BFS），在Java里用队列来搞定，那真是再合适不过了。核心思想很简单：一层一层地往下走，确保你把当前层的所有节点都处理完了，才去处理下一层。而队列的先进先出（FIFO）特性，完美地契合了这种“排队”处理的逻辑。

解决方案

要用Java代码实现二叉树的层次遍历，我们通常会用到

java.util.Queue

接口及其实现类，比如

LinkedList

或者

ArrayDeque

。下面是一个基本的实现思路和代码示例：

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

// 假设我们有一个简单的二叉树节点定义
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class LevelOrderTraversal {

    public List> levelOrder(TreeNode root) {
        List> result = new LinkedList<>();
        // 如果根节点是空的，直接返回空列表
        if (root == null) {
            return result;
        }

        // 初始化一个队列，用于存放待访问的节点
        Queue queue = new LinkedList<>();
        // 将根节点加入队列
        queue.offer(root); // offer比add更安全，不会抛出异常

        // 当队列不为空时，循环处理
        while (!queue.isEmpty()) {
            // 获取当前层级的节点数量，这是关键！
            int levelSize = queue.size();
            List currentLevelNodes = new LinkedList<>();

            // 遍历当前层的所有节点
            for (int i = 0; i < levelSize; i++) {
                // 从队列中取出节点
                TreeNode currentNode = queue.poll(); // poll比remove更安全，返回null而非抛出异常
                currentLevelNodes.add(currentNode.val);

                // 将当前节点的左右子节点（如果存在）加入队列，等待下一轮处理
                if (currentNode.left != null) {
                    queue.offer(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.offer(currentNode.right);
                }
            }
            // 将当前层的所有节点值列表加入结果集
            result.add(currentLevelNodes);
        }
        return result;
    }

    // 简单的主方法用于测试
    public static void main(String[] args) {
        // 构建一个示例二叉树
        //      3
        //     / \
        //    9  20
        //      /  \
        //     15   7
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(9);
        root.right = new TreeNode(20);
        root.right.left = new TreeNode(15);
        root.right.right = new TreeNode(7);

        LevelOrderTraversal solver = new LevelOrderTraversal();
        List> levels = solver.levelOrder(root);

        System.out.println("层次遍历结果:");
        for (List level : levels) {
            System.out.println(level);
        }
        // 预期输出:
        // [3]
        // [9, 20]
        // [15, 7]
    }
}

这段代码的核心在于那个

levelSize

变量。每次外层循环开始时，我们都记录下队列里当前有多少个节点，这代表了当前层的所有节点。然后，我们内层循环就只处理这

levelSize

个节点，并把它们的子节点加到队列里，这些子节点自然就成了下一层的待处理对象。这样，一层一层的顺序就保证了。

立即学习“Java免费学习笔记（深入）”；

为什么队列是实现层次遍历的理想选择？

我觉得队列最核心的价值，就在于它的“排队”逻辑。你想啊，我们平时排队买东西、等公交，是不是都是先来先服务？队列（Queue）这个数据结构，就是严格遵循“先进先出”（First-In, First-Out, FIFO）原则的。

在层次遍历中，我们希望先访问距离根节点近的节点，再访问距离远的。具体到每一层，就是先访问左边的节点，再访问右边的节点，而且必须把当前层的所有节点都访问完，才能“晋升”到下一层。队列正好提供了这种机制：

造好物

一站式AI造物设计平台

下载

你把根节点放进去，它是第一个。
然后你取出根节点，处理它，再把它所有的子节点（也就是下一层的第一批节点）放进去。
接着你继续从队列头部取节点，这些节点自然就是当前层还没处理完的那些。
当你把当前层的所有节点都取完并处理掉后，队列里剩下的就全是下一层的节点了，而且它们也已经按照从左到右的顺序排好了队。

相比之下，如果你用栈（Stack）来做，那就是“后进先出”（LIFO），那更适合深度优先搜索（DFS），会一路扎到底，而不是一层一层地展开。所以，队列的FIFO特性，是它能完美实现层次遍历的根本原因。

队列在Java中还有哪些常见的应用场景？

当然，队列的应用可不止遍历树这么简单。在日常的编程和系统设计里，队列简直是无处不在，而且很多时候，它就是解决并发、削峰、解耦问题的银弹。

我个人最常用到队列的几个场景大概是：

任务调度与处理： 这是最经典的用法了。比如，Web服务器处理用户请求，每个请求都可以看作一个任务，把它们扔进一个任务队列里，然后后台的线程池再从队列里取任务来执行。这样可以平滑地处理突发流量，避免系统过载。Java的
```
ExecutorService
```
底层就大量使用了队列来管理任务。
消息队列系统： 像Kafka、RabbitMQ这些分布式消息系统，核心就是队列。生产者把消息扔进队列，消费者从队列里取消息。这能实现系统间的异步通信和解耦，比如订单系统生成订单后，把消息发到队列，库存系统、物流系统再各自去队列里取消息处理，互不干扰。
缓存管理： 有些缓存淘汰策略，比如LRU（Least Recently Used）的变种，或者简单的FIFO缓存，就会用到队列来追踪元素的访问顺序或插入顺序，以便在缓存满时决定淘汰哪个元素。
图的广度优先搜索（BFS）： 除了树的层次遍历，任何图的BFS算法，也都是基于队列实现的。比如，寻找最短路径（在无权图中），或者社交网络中查找“一度好友”。
模拟排队系统： 比如银行柜台、超市收银台的模拟程序，用队列来模拟顾客排队等待服务的过程，可以用来分析系统吞吐量、等待时间等。

在并发编程中，

java.util.concurrent

包下的

BlockingQueue

更是神器，它提供了线程安全的队列操作，并且支持阻塞式地存取元素，这对于实现生产者-消费者模式简直太方便了。

在实际项目中，使用队列时需要注意哪些潜在问题？

虽然队列很好用，但在实际项目中，我们用起来还是得留心一些潜在的问题。有时候，我发现大家在用队列时，最容易忽视的就是这些“坑”。

内存消耗： 这是一个大头。如果你的队列里存储的对象很大，或者队列中的元素数量非常庞大（比如处理海量消息），那么队列可能会占用大量的内存。特别是在层次遍历这种场景，如果树的宽度很大，某一层的节点数量会非常多，队列里会同时存放这一层和下一层甚至更多层的节点，这时候内存占用就得警惕了。搞不好就来个
```
OutOfMemoryError
```
。
线程安全： 如果你的队列会被多个线程同时访问（比如一个线程往里加任务，另一个线程从里取任务），那么你必须使用线程安全的队列实现。
```
java.util.LinkedList
```
和
```
java.util.ArrayDeque
```
都不是线程安全的，它们适用于单线程环境。在多线程环境，你应该考虑使用
```
java.util.concurrent
```
包下的类，比如
```
ConcurrentLinkedQueue
```
（非阻塞，性能好）或者各种
```
BlockingQueue
```
的实现（如
```
ArrayBlockingQueue
```
、
```
LinkedBlockingQueue
```
，支持阻塞操作）。
空元素处理： 大多数
```
Queue
```
实现不允许存储
```
null
```
元素。如果你不小心往队列里扔了个
```
null
```
，可能会遇到
```
NullPointerException
```
。当然，在层次遍历中，我们通常不会把
```
null
```
节点放进去。
性能考量： 不同的队列实现有不同的性能特点。
```
LinkedList
```
在插入和删除头部/尾部元素时效率高，但随机访问慢。
```
ArrayDeque
```
基于数组，对于头部和尾部的操作也很快，而且通常比
```
LinkedList
```
更节省内存。在选择时，要根据你的具体场景来权衡。
队列满/空的处理： 对于有界队列（如
```
ArrayBlockingQueue
```
），当队列满时，
```
offer()
```
方法可能会返回
```
false
```
或者阻塞。当队列空时，
```
poll()
```
方法可能会返回
```
null
```
或者阻塞。在设计消费者/生产者逻辑时，必须妥善处理这些情况，避免死锁或数据丢失。
资源泄漏： 如果队列中存放的是需要手动关闭的资源（比如文件句柄、数据库连接等），那么在从队列中取出并处理这些资源后，一定要确保它们被正确关闭或释放，否则可能导致资源泄漏。