leetcode323. Number of Connected Components in an Undirected Graph

最新推荐文章于 2025-02-03 15:37:10 发布

原创最新推荐文章于 2025-02-03 15:37:10 发布 · 505 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 同时被 3 个专栏收录

187 篇文章

订阅专栏

算法-并查集

3 篇文章

订阅专栏

算法-bfs

2 篇文章

订阅专栏

本文介绍两种高效算法来寻找无向图中的所有连通分量：一种使用广度优先搜索（BFS），另一种采用并查集（Union Find）。通过这两种方法可以将图中的节点按其所属的连通分量进行分组。

解法一

bfs

/**
 * @Author taotao
 * @Date 9/8/17
 */

class UndirectedGraphNode {
    int label;
    ArrayList<UndirectedGraphNode> neighbors;
    UndirectedGraphNode(int x) {
        label = x;
        neighbors = new ArrayList<UndirectedGraphNode>();
    }
};

public class FindTheConnectedComponentInTheUndirectedGraph_lint_3 {
    public List<List<Integer>> connectedSet(ArrayList<UndirectedGraphNode> nodes) {
        Map<UndirectedGraphNode, Boolean> visited = new HashMap<>();
        for (UndirectedGraphNode node : nodes) {
            visited.put(node, false);
        }
        List<List<Integer>> result = new ArrayList<>();
        for (UndirectedGraphNode node : nodes) {
            if (visited.get(node) == false) {
                bfs(node, visited, result);
            }
        }

        return result;
    }
    public void bfs(UndirectedGraphNode node, Map<UndirectedGraphNode, Boolean> visited,
                    List<List<Integer>> result) {
        List<Integer> row = new ArrayList<>();
        Queue<UndirectedGraphNode> queue = new LinkedList<>();
        visited.put(node, true);
        queue.offer(node);
        while (!queue.isEmpty()) {
            UndirectedGraphNode u = queue.poll();
            row.add(u.label);
            for (UndirectedGraphNode v : u.neighbors) {
                if (visited.get(v) == false) {
                    visited.put(v, true);
                    queue.offer(v);
                    row.add(v.label);
                }
            }
        }

        Collections.sort(row);
        result.add(row);
    }
    public static void main(String[] args) {
        FindTheConnectedComponentInTheUndirectedGraph_lint_3 model = new FindTheConnectedComponentInTheUndirectedGraph_lint_3();
        UndirectedGraphNode a = new UndirectedGraphNode(1);
        UndirectedGraphNode b = new UndirectedGraphNode(2);
        ArrayList<UndirectedGraphNode> list = new ArrayList<>();
        list.add(a);
        list.add(b);
        List<List<Integer>> l = model.connectedSet(list);
        System.out.print(l);
    }
}

解法二

UnionFind

/**
 * @Author RenXintao
 * @Date 9/8/17
 * @method: UnionFind
 */
class UnionFind {
    HashMap<Integer, Integer> father = new HashMap<>();
    UnionFind(HashSet<Integer> hashSet) {
        for (Integer now : hashSet) {
            father.put(now, now);
        }
    }
    int find(int x) {
        int parent = father.get(x);
        while (parent != father.get(parent)) {
            parent = father.get(parent);
        }

        return parent;
    }
    int compressed_find(int x) {
        int parent = father.get(x);
        while (parent != father.get(parent)) {
            parent = father.get(parent);
        }

        int next;
        while (x != father.get(x)) {
            next = father.get(x);
            father.put(x, parent);
            x = next;
        }

        return parent;
    }
    void union(int x, int y) {
        int fa_x = father.get(x);
        int fa_y = father.get(y);
        if (fa_x != fa_y) {
            father.put(fa_x, fa_y);
        }
    }

}
public class FindTheConnectedComponentInTheUndirectedGraph_lint_3_1 {
    List<List<Integer>> print(HashSet<Integer> hashSet, UnionFind uf, int n) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        HashMap<Integer, List<Integer>> hashMap = new HashMap<Integer, List<Integer>>();
        for (int i : hashSet) {
            int fa = uf.find(i);
            if (!hashMap.containsKey(fa)) {
                hashMap.put(fa, new ArrayList<Integer>());
            }
            List<Integer> now = hashMap.get(fa);
            now.add(i);
            hashMap.put(fa, now);
        }

        for (List<Integer> now : hashMap.values()) {
            Collections.sort(now);
            ans.add(now);
        }

        return ans;
    }
    public List<List<Integer>> connnectedSet(ArrayList<UndirectedGraphNode> nodes) {
        HashSet<Integer> hashSet = new HashSet<>();
        for (UndirectedGraphNode now : nodes) {
            hashSet.add(now.label);
            for (UndirectedGraphNode neighbour : now.neighbors) {
                hashSet.add(neighbour.label);
            }
        }

        UnionFind uf = new UnionFind(hashSet);

        for (UndirectedGraphNode now : nodes) {
            for (UndirectedGraphNode neighbour : now.neighbors) {
                int fnow = uf.find(now.label);
                int fneighbour = uf.find(neighbour.label);
                if (fnow != fneighbour) {
                    uf.union(now.label, neighbour.label);
                }
            }
        }

        return print(hashSet, uf, nodes.size());
    }
}