搜索算法之广度优先搜索详细解读（附带Java代码解读）

南城花随雪。

于 2024-09-08 00:00:00 发布

阅读量453

点赞数 18

分类专栏：算法分析文章标签：宽度优先算法

本文链接：https://blog.csdn.net/m0_61840987/article/details/141963521

版权

算法分析专栏收录该内容

45 篇文章 0 订阅

订阅专栏

广度优先搜索（BFS）详细介绍

1. 基本概念

树结构：在树结构中，BFS 从根节点开始，首先访问根节点的所有直接子节点，然后访问这些子节点的子节点，逐层向下进行遍历。
图结构：在图结构中，BFS 从一个起始节点开始，访问所有直接相邻的节点，然后访问这些节点的邻接节点，逐层向外扩展。

2. 工作原理

广度优先搜索的基本步骤如下：

初始化：
- 使用一个队列来跟踪待访问的节点。
- 初始化一个集合或标记来记录已访问的节点。
访问节点：
- 从队列中取出一个节点，访问该节点。
- 遍历该节点的所有邻居节点，将所有未访问的邻居节点添加到队列中，并标记为已访问。
重复：
- 重复上述步骤，直到队列为空或找到目标节点。
结束条件：
- 如果队列为空，说明所有节点已被访问。
- 如果找到目标节点，可以提前结束搜索。

3. 算法步骤

以下是广度优先搜索的详细步骤：

输入：
- 一个图或树，通常以邻接表或邻接矩阵表示。
- 起始节点。
步骤：
- 初始化一个队列和一个集合（或标记）来记录访问状态。
- 将起始节点加入队列，并标记为已访问。
- 进入循环：
  - 从队列中取出一个节点。
  - 访问该节点并处理（例如打印节点值或执行某个操作）。
  - 遍历该节点的所有邻居节点，将所有未访问的邻居节点加入队列，并标记为已访问。
- 继续直到队列为空（或找到目标节点）。
结束条件：
- 如果所有节点都已访问，算法结束。
- 如果在某些情况下找到目标节点，可以提前结束。

4. 时间复杂度分析

时间复杂度：在图结构中，广度优先搜索的时间复杂度是 O(V + E)，其中 V 是图中的节点数，E 是图中的边数。对于树结构，时间复杂度为 O(V)，其中 V 是树中的节点数。
空间复杂度：
- 队列：在最坏情况下，队列的空间复杂度为 O(V)，取决于树或图的宽度。
- 已访问集合：需要额外的空间来存储已访问的节点，空间复杂度为 O(V)。

5. 实现代码

import java.util.*;

public class BreadthFirstSearch {

    // 使用队列实现的BFS
    public static void bfs(Map<Integer, List<Integer>> graph, int start) {
        Set<Integer> visited = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();
        
        queue.add(start);
        visited.add(start);

        while (!queue.isEmpty()) {
            int node = queue.poll();
            System.out.print(node + " ");

            for (int neighbor : graph.get(node)) {
                if (!visited.contains(neighbor)) {
                    queue.add(neighbor);
                    visited.add(neighbor);
                }
            }
        }
    }

    public static void main(String[] args) {
        // 图的邻接表表示
        Map<Integer, List<Integer>> graph = new HashMap<>();
        graph.put(1, Arrays.asList(2, 3));
        graph.put(2, Arrays.asList(1, 4, 5));
        graph.put(3, Arrays.asList(1, 6));
        graph.put(4, Arrays.asList(2));
        graph.put(5, Arrays.asList(2));
        graph.put(6, Arrays.asList(3));

        // 执行广度优先搜索
        System.out.println("BFS:");
        bfs(graph, 1);
    }
}

代码解读：

public static void bfs(Map<Integer, List<Integer>> graph, int start)：
- 定义了一个静态方法 bfs，接受两个参数：一个图的邻接表表示 graph 和一个起始节点 start。
- 方法使用队列来实现广度优先搜索。
Set<Integer> visited = new HashSet<>();：
- 用于记录已访问的节点。
Queue<Integer> queue = new LinkedList<>();：
- 用于实现队列操作，保存待访问的节点。
queue.add(start); visited.add(start);：
- 将起始节点加入队列，并标记为已访问。
while (!queue.isEmpty())：
- 循环处理队列中的节点，访问节点，并将未访问的邻居节点加入队列。
System.out.print(node + " ");：
- 打印当前访问的节点。