广度优先搜索简介

概念：

广度优先搜索（BFS）是一种图搜索算法，用于在图或树数据结构中寻找特定节点或路径。它从起始节点开始，逐层遍历图中的节点，直到找到目标节点或遍历完整个图。

BFS解决的问题是在一个图中寻找最短路径或最少步骤来达到目标节点。它可以用于解决迷宫问题、网络路由问题、社交网络中的关系查找等。

算法特点：

• 按层级遍历图中的节点，即先访问起始节点，然后访问与起始节点直接相邻的节点，再访问与这些相邻节点相邻的节点，以此类推。它使用队列数据结构来保存待访问的节点，确保按照先进先出的顺序进行遍历。

优点：

• 可以找到最短路径或最少步骤的解决方案。
• 可以遍历整个图，确保不会遗漏任何节点。
• 适用于无权图，每条边的权重相同的情况。

缺点：

• 当图非常大时，需要较大的内存空间来存储遍历过程中的节点。
• 对于有权图，每条边的权重不相同时，BFS可能不是最优解决方案。

适用场景：

• 在无权图中查找最短路径或最少步骤的解决方案。
• 需要遍历整个图，确保不会遗漏任何节点。
• 在图中查找特定节点或路径。

实现代码：

这个代码创建了一个图，并使用LinkedList表示。然后，我们使用BFS算法来找到从起始节点到目标节点的最短路径。在main方法中，我们创建了一个图并指定起始节点和目标节点。然后调用BFS方法来执行搜索并打印最短路径。

import java.util.*;
 
public class BFSAlgorithm {
    private int V; // 图中节点的数量
    private LinkedList[] adj; // 邻接表表示的图
 
    public BFSAlgorithm(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i)
            adj[i] = new LinkedList();
    }
 
    // 添加边
    void addEdge(int v, int w) {
        adj[v].add(w);
    }
 
    // 使用BFS算法找到从起始节点到目标节点的最短路径
    void BFS(int start, int target) {
        boolean[] visited = new boolean[V]; // 用于标记节点是否被访问过
        int[] parent = new int[V]; // 用于记录每个节点的父节点
        Arrays.fill(parent, -1);
 
        LinkedList queue = new LinkedList<>();
 
        visited[start] = true;
        queue.add(start);
 
        while (queue.size() != 0) {
            int current = queue.poll();
 
            // 找到目标节点，打印最短路径并返回
            if (current == target) {
                printPath(parent, target);
                return;
            }
 
            Iterator iterator = adj[current].listIterator();
            while (iterator.hasNext()) {
                int next = iterator.next();
                if (!visited[next]) {
                    visited[next] = true;
                    parent[next] = current;
                    queue.add(next);
                }
            }
        }
 
        // 如果无法找到目标节点，打印提示信息
        System.out.println("无法找到从起始节点到目标节点的路径");
    }
 
    // 打印最短路径
    void printPath(int[] parent, int target) {
        LinkedList path = new LinkedList<>();
        int current = target;
        path.add(current);
 
        while (parent[current] != -1) {
            path.addFirst(parent[current]);
            current = parent[current];
        }
 
        System.out.println("最短路径为：" + path);
    }
 
    public static void main(String[] args) {
        BFSAlgorithm graph = new BFSAlgorithm(6);
 
        // 添加边
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);
        graph.addEdge(2, 4);
        graph.addEdge(3, 5);
        graph.addEdge(4, 5);
 
        int start = 0; // 起始节点
        int target = 5; // 目标节点
 
        System.out.println("从节点 " + start + " 到节点 " + target + " 的最短路径为：");
        graph.BFS(start, target);
    }
}