并查集实现
并查集的本质是通过一个一维数组来维护一个森林。开始时森林中的每一个节点都是孤立的,各自形成一个树。之后,进行若干次的合并操作,每次合并将两个树合并为一个更大的树。
实现思路
代码实现
import java.util.HashMap;
import java.util.List;
import java.util.Stack;
public class Code05_UnionFind {
public static class Node<V> {
V value;
public Node(V v) {
value = v;
}
}
public static class UnionFind<V> {
// 值和Node的映射关系
public HashMap<V, Node<V>> nodes;
// 指向自己父类的集合
public HashMap<Node<V>, Node<V>> parents;
// 表明当前代表节点所表示的集合的大小
public HashMap<Node<V>, Integer> sizeMap;
public UnionFind(List<V> values) {
this.nodes = new HashMap<>();
this.parents = new HashMap<>();
this.sizeMap = new HashMap<>();
// 初始化三个集合
for (V value : values) {
Node<V> node = new Node<>(value);
nodes.put(value, node);
parents.put(node, node);
sizeMap.put(node, 1);
}
}
// 给你一个节点,请你往上到不能再往上,把代表返回
public Node<V> findFather(Node<V> cur) {
Stack<Node<V>> path = new Stack<>();
// 当cur的父节点不是他自己的时候, 一直向上找到代表结点
while (cur != parents.get(cur)) {
path.push(cur);
cur = parents.get(cur);
}
// 将路径上的节点父类都设置为代表结点
while (!path.isEmpty()) {
parents.put(path.pop(), cur);
}
return cur;
}
// 两个值是否在同一个集合中
public boolean isSameSet(V a, V b) {
return findFather(nodes.get(a)) == findFather(nodes.get(b));
}
// 合并a,b两个元素所在集合
public void union(V a, V b) {
// 首先获取两个元素的代表节点
Node<V> aHead = findFather(nodes.get(a));
Node<V> bHead = findFather(nodes.get(b));
// 如果aHead == bHead 表示两集合代表节点一致,不需要合并
if (aHead != bHead) {
// 获取两集合大小
Integer aSetSize = sizeMap.get(aHead);
Integer bSetSize = sizeMap.get(bHead);
// 拿到较大和较小的集合的代表节点
Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
Node<V> small = big == aHead ? bHead : aHead;
// 将较小集合的代表节点指向较大结合的代表节点
parents.put(small, big);
// 更新大集合大小,删除小集合
sizeMap.put(big, aSetSize + bSetSize);
sizeMap.remove(small);
}
}
public int sets() {
return sizeMap.size();
}
}
}
相关题目
LeetCode 547. 省份数量
思路
代码实现
class Solution {
public int findCircleNum(int[][] isConnected) {
int N = isConnected.length;
// 初始化并查集 0 1 2 ... N-1
UnionFind unionFind = new UnionFind(N);
for(int i = 0; i < N; i++) {
for(int j = i + 1; j < N; j++) {
if(isConnected[i][j] == 1) {
unionFind.union(i, j);
}
}
}
return unionFind.set();
}
// 数组实现并查集
public class UnionFind {
// parent[i] = k: i 的父亲是 k
public int[] parent;
// size[i] = k: 如果i是代表节点,size[i]才有意义,表示i所在集合的大小
public int[] size;
// 辅助数组,作为栈存在
public int[] help;
// 一共有多少个集合
public int sets;
// 初始化
public UnionFind(int N) {
parent = new int[N];
size = new int[N];
help = new int[N];
sets = N;
for(int i = 0; i < N; i++) {
parent[i] = i;
size[i] = 1;
}
}
// 从i开始一直往上,往上到不能再往上,代表节点,返回
// 这个过程要做路径压缩
public int find(int i) {
int hi = 0;
// 向上找父节点,最后i就是代表节点
while(i != parent[i]) {
help[hi++] = i;
i = parent[i];
}
// 压缩路径
for(hi--; hi >= 0; hi--) {
parent[help[hi]] = i;
}
return i;
}
// 合并方法
public void union(int i, int j) {
// 先找到两个值的代表节点
int f1 = find(i);
int f2 = find(j);
// 如果两个值不在同一个集合中
if(f1 != f2) {
if(size[f1] >= size[f2]) {
size[f1] += size[f2];
parent[f2] = f1;
} else {
size[f2] += size[f1];
parent[f1] = f2;
}
// 两个集合合并,集合数量减一
sets--;
}
}
public int set() {
return sets;
}
}
}