Java中的深度优先搜索与广度优先搜索：算法实现与应用场景

最新推荐文章于 2024-09-06 10:50:05 发布

省赚客app开发者

最新推荐文章于 2024-09-06 10:50:05 发布

阅读量1.2k

点赞数 25

文章标签：深度优先算法 java

本文链接：https://blog.csdn.net/weixin_44409190/article/details/141268584

版权

Java中的深度优先搜索与广度优先搜索：算法实现与应用场景

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！作为开头。

深度优先搜索（DFS）和广度优先搜索（BFS）是图论中的两种基本搜索算法。它们在图的遍历、路径查找、连通性检测等任务中具有重要作用。本文将介绍这两种算法的原理、Java实现以及应用场景，帮助你更好地理解和运用这两种算法。

1. 深度优先搜索（DFS）

深度优先搜索是一种优先探索图的深度的算法。它从起始节点开始，沿着一个路径尽可能深地搜索，直到无法继续为止，然后回溯并探索其他路径。DFS 可以使用递归或栈来实现。

1.1 算法原理

选择一个起始节点。
访问该节点。
递归访问所有未被访问的邻接节点。
回溯：当当前节点的所有邻接节点都被访问过后，返回到上一个节点继续探索其他路径。
结束：所有节点都被访问完毕。

1.2 Java 实现

package cn.juwatech.graph;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class DepthFirstSearch {

    private static void dfsRecursive(int node, boolean[] visited, List<Integer>[] graph) {
        visited[node] = true;
        System.out.print(node + " ");

        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                dfsRecursive(neighbor, visited, graph);
            }
        }
    }

    public static void dfs(int startNode, List<Integer>[] graph) {
        boolean[] visited = new boolean[graph.length];
        dfsRecursive(startNode, visited, graph);
    }

    public static void main(String[] args) {
        int n = 6; // 节点数
        List<Integer>[] graph = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }

        graph[0].add(1);
        graph[0].add(2);
        graph[1].add(3);
        graph[1].add(4);
        graph[2].add(5);

        System.out.println("深度优先搜索结果：");
        dfs(0, graph);
    }
}

代码说明

dfsRecursive 方法：递归实现 DFS，访问当前节点并递归访问其所有未访问的邻接节点。
dfs 方法：初始化访问标记并启动递归 DFS。
main 方法：构建一个简单的图，并调用 dfs 方法进行深度优先搜索。

2. 广度优先搜索（BFS）

广度优先搜索是一种优先探索图的广度的算法。它从起始节点开始，首先访问所有与起始节点直接相连的节点，然后逐层向外扩展，直到所有节点都被访问为止。BFS 通常使用队列来实现。

2.1 算法原理

选择一个起始节点。
将起始节点加入队列。
从队列中取出一个节点：
- 访问该节点。
- 将所有未被访问的邻接节点加入队列。
继续：重复上述步骤，直到队列为空。
结束：所有节点都被访问完毕。

2.2 Java 实现

package cn.juwatech.graph;

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

public class BreadthFirstSearch {

    public static void bfs(int startNode, List<Integer>[] graph) {
        boolean[] visited = new boolean[graph.length];
        Queue<Integer> queue = new LinkedList<>();
        
        visited[startNode] = true;
        queue.add(startNode);

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

            for (int neighbor : graph[node]) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue.add(neighbor);
                }
            }
        }
    }

    public static void main(String[] args) {
        int n = 6; // 节点数
        List<Integer>[] graph = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }

        graph[0].add(1);
        graph[0].add(2);
        graph[1].add(3);
        graph[1].add(4);
        graph[2].add(5);

        System.out.println("广度优先搜索结果：");
        bfs(0, graph);
    }
}

代码说明

bfs 方法：使用队列实现 BFS，访问当前节点并将所有未访问的邻接节点加入队列。
main 方法：构建一个简单的图，并调用 bfs 方法进行广度优先搜索。

3. 应用场景

深度优先搜索（DFS）：
- 拓扑排序：在有向图中确定节点的排列顺序。
- 强连通分量：在有向图中找到所有强连通分量。
- 路径查找：寻找从源节点到目标节点的路径。
广度优先搜索（BFS）：
- 最短路径：在无权图中寻找从源节点到目标节点的最短路径。
- 图的层次遍历：按层次遍历图节点。
- 连通性检测：检查图是否是连通的。