leetcode| 323. Number of Connected Components in an Undirected Graph(并查集/DFS/BFS)-优快云博客

该博客介绍了如何解决LeetCode第323题，即求解无向图中连通组件的数量。文章分析了三种解法：深度优先搜索(DFS)、广度优先搜索(BFS)以及并查集，并讨论了它们的时间复杂度，指出并查集在使用路径压缩后的效率最高。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

题目描述：一张含n节点的无向图，以及一组无向边，编写一个函数来查找无向图中连接的组件的数量。

Input: n = 5 and edges = [[0, 1], [1, 2], [3, 4]]

     0          3
     |          |
     1 --- 2    4 

Output: 2

分析

解法DFS/BFS/并查集，DFS和BFS时间复杂度均为O(e + n), 并查集时间复杂度O(e + n)(路径压缩的权重quickUnion算法union接近O(1));e是edges的长度，n是节点数量；

解法

DFS

public class Solution {
    // 搜索区域
    private Map<Integer, List<Integer>> relation = new HashMap<>();
    
    // 已搜索的标志，当然也可以用Set
    private boolean[] hasSearch;

    public int countComponents(int n, int[][] edges) {
        if (n < 1) {
            return 0;
        }
        hasSearch = new boolean[n];
        for (int i = 0; i < n; i++) {
            relation.put(i, new LinkedList<>());
        }

        // 关键：构建一个搜索区域，不像《岛屿的数量》题目直接构建好了搜索区域int[][] grid;
        for (int i = 0; i < edges.length; i++) {
            relation.get(edges[i][0]).add(edges[i][1]);
            relation.get(edges[i][1]).add(edges[i][0]);
        }

        int count = 0;
        
        // 连通图问题的计算数量的模版
        for (int i = 0; i < n; i++) {
            if (!hasSearch[i]) {
                dfs(i);
                count++;
            }
        }
        return count;
    }

    private void dfs(int i) {
        for (Integer son : relation.get(i)) {
            if (!hasSearch[son]) {
                hasSearch[son] = true;
                dfs(son);
            }
        }
    }
}

BFS

public class Solution {
    private Map<Integer, List<Integer>> relation = new HashMap<>();
    private boolean[] hasSearch;

    public int countComponents(int n, int[][] edges) {
        if (n < 1) {
            return 0;
        }
        hasSearch = new boolean[n];
        for (int i = 0; i < n; i++) {
            relation.put(i, new LinkedList<>());
        }

        for (int i = 0; i < edges.length; i++) {
            relation.get(edges[i][0]).add(edges[i][1]);
            relation.get(edges[i][1]).add(edges[i][0]);
        }

        int count = 0;
        Queue<Integer> queue = new LinkedList<>();

        for (int i = 0; i < n; i++) {
            if (!hasSearch[i]) {
                count++;
                queue.clear();
                queue.add(i);
                while (!queue.isEmpty()) {
                    int cur = queue.poll();
                    if (!hasSearch[cur]) {
                        hasSearch[cur] = true;
                        for (Integer e : relation.get(cur)) {
                            if (!hasSearch[e]) {
                                queue.offer(e);
                            }
                        }
                    }
                }
            }
        }
        return count;
    }