BFS与队列实现

BFS与队列实现

基本概念

BFS 是广度优先搜索的缩写，是一种图论搜索算法。它的基本思想是从图的某一个起始顶点开始，先将这个顶点的所有邻接点依次遍历一遍，再按照它们与起始点的距离由近到远的次序依次进行遍历。换句话说，BFS 是从起始点开始逐层向外扩散，在此过程中每一层遍历到的顶点都和起始点的距离相同。

BFS 通常使用队列来实现。我们将起始点放入队列中，然后以宽度优先的方式扩展队列，将队列中的元素依次取出，再将它们的所有邻接点加入队列尾部，直到队列为空。

队列概述

队列是一种常见的数据结构，它具有先进先出（FIFO）的特点。在队列中，新的元素总是添加到队列的末尾（称为队尾），而旧的元素总是从队列的前面（称为队头）被移除。队列通常用于在多个线程之间共享数据，或者在算法中执行广度优先搜索等任务。

Java中提供了Queue接口来表示队列。Queue接口扩展了Collection接口，提供了专门针对队列操作的方法。

基本操作

使用LinkedList创建队列

通常使用LinkedList类来实现队列这种数据结构，在Java中创建一个队列很简单，只需要使用LinkedList即可：

Queue<String> queue = new LinkedList<>();

在上面的例子中，我们创建了一个名为queue的字符串队列。

向队列添加元素

可以使用offer()方法将元素添加到队列的末尾：

queue.offer("A");

在上面的例子中，我们向队列中添加了一个名为"A"的元素。

从队列中删除元素

可以使用poll()方法从队列中移除并返回队头元素：

String element = queue.poll();

在上面的例子中，我们从队列中移除队头元素，并将其保存在一个名为element的字符串变量中。

如果队列为空，则poll()方法会返回null。

获取队头元素

可以使用peek()方法获取队头元素，但是不会从队列中删除它：

String element = queue.peek();

在上面的例子中，我们获取队头元素，并将其保存在一个名为element的字符串变量中。

如果队列为空，则peek()方法会返回null。

遍历队列

可以使用增强型for循环或迭代器来遍历队列中的所有元素：

// 使用增强型for循环
for (String element : queue) {
    System.out.println(element);
}

// 使用迭代器
Iterator<String> iterator = queue.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

在上面的例子中，我们使用增强型for循环和迭代器来遍历队列中的所有元素，并打印每个元素的值。

例题分析

下面是几道leetcode上关于队列和bfs的题目

剑指 Offer 32 - I. 从上到下打印二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] levelOrder(TreeNode root) {
        if(root == null){
            return new int[0];
        }

        List<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            list.add(node.val);
            if(node.left != null){
                queue.offer(node.left);
            }
            if(node.right != null){
                queue.offer(node.right);
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}   

剑指 Offer 32 - II. 从上到下打印二叉树 II

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();

                list.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            res.add(list);
        }
        return res;
    }
}

剑指 Offer 32 - III. 从上到下打印二叉树 III

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        // 使用 Deque 双端队列
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int level = 1; // 计数器，当前层级

        while (!queue.isEmpty()) { // 循环条件改为队列非空
            int size = queue.size();
            Deque<Integer> deque = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (level % 2 == 1) { // 奇数层
                    deque.offerLast(node.val);
                } else {
                    deque.offerFirst(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            level++; // 需要增加层数
            res.add(new ArrayList<>(deque));
        }
        return res;
    }
}