目录
需求描述
假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路
设计一个数据结构，能够快速执行2个操作:
- 查询2个村庄之间是否有连接的路
- 连接2个村庄
使用数组、链表、平衡二叉树、集合(Set),查询、连接的时间复杂度都是: O(n)
并查集能够办到查询、连接的均摊时间复杂度都是 O(α(n)), α(n) < 5
并查集非常适合解决这类“连接”相关的问题
基础概念
并查集也叫作不相交集合(Disjoint Set)
并查集有2个核心操作
查找(Find): 查找元素所在的集合(这里的集合并不是特指Set这种数据结构, 是指广义的数据集合)
合并(Union): 将两个元素所在的集合合并为一个集合
有2种常见的实现思路
Quick Find
查找(Find)的时间复杂度: O(1)
合并(Union)的时间复杂度: O(n)
Quick Union
查找(Find)的时间复杂度: O(logn)，可以优化至 O(α(n)), α(n) < 5
合并(Union)的时间复杂度: O(logn)，可以优化至 O(α(n)), α(n) < 5
假设并查集处理的数据都是整型，那么可以用整型数组来存储数据:
不难看出:
0、1、3 属于同一集合
2 单独属于一个集合
4、5、6、7 属于同一集合
因此，并查集是可以用数组实现的树形结构 (二叉堆、优先级队列也是可以用数组实现的树形结构)
接口定义
package com.lic.UnionFind;
public abstract class UnionFind {
protected int[] parents;
public UnionFind(int capacity) {
if(capacity < 0){
throw new IllegalArgumentException("Capacity must be >=1");
}
parents = new int[capacity];
//parents初始化,每个元素的父元素默认为自己
for (int i = 0; i < parents.length ; i++) {
parents[i] = i;
}
}
/**
* 查找v所属的集合（根节点）
* @param v
* @return
*/
public abstract int find(int v);
/**
* 合并v1、v2所在的集合
*/
public abstract void union(int v1, int v2);
/**
* 检查v1、v2是否属于同一个集合
*/
public boolean isSame(int v1, int v2) {
return find(v1) == find(v2);
}
/**
* 索引范围检查
* @param v
*/
protected void rangeCheck(int v){
if (v < 0 || v >= parents.length) {
throw new IllegalArgumentException("v is out of bounds");
}
}
}注意: 初始化时，每个元素各自属于一个单元素集合
Quick Find
Quick Find – Union
Quick Find 的 union(v1, v2)：让 v1 所在集合的所有元素都指向 v2 的根节点
代码实现:
/**
* 将v1所在集合的所有元素，都嫁接到v2的父节点上
*/
@Override
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if(p1 == p2) return ;
/**
* 遍历parent数组, 所有父元素与v1相同的元素都需要修改为v2的父元素
*/
for (int i = 0; i < parents.length; i++) {
if(parents[i] == p1){
parents[i] = p2;
}
}
}
时间复杂度: O(n)
Quick Find – Find
代码实现:
/**
* 父元素就是根节点
*/
@Override
public int find(int v) {
rangeCheck(v);
return parents[v];
}
find(0) == 2
find(1) == 2
find(3) == 4
find(2) == 2
时间复杂度：O(1)
Quick Union
Quick Union – Union
Quick Union 的 union(v1, v2)：让 v1 的根节点指向 v2 的根节点
代码实现:
/**
* 将v1所在的集合嫁接到v2的根节点上
*/
@Override
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if(p1 == p2) return ;
parents[p1] = p2;
}
时间复杂度：O(logn)
Quick Union – Find
/**
* 通过parent链条不断地向上找，直到找到根节点
*/
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]){
v = parents[v];
}
return parents[v];
}find(0) == 2
find(1) == 2
find(3) == 2
find(2) == 2
时间复杂度: O(logn)
Quick Union – 优化
在Union的过程中，可能会出现树不平衡的情况，甚至退化成链表
有2种常见的优化方案:
基于size的优化：元素少的树 嫁接到 元素多的树
基于rank的优化：矮的树 嫁接到 高的树
Quick Union – 基于size的优化
package com.lic.UnionFind;
/**
* Quick Union 基于size的优化
*/
public class UnionFind_QU_S extends UnionFind_QU{
private int[] sizes;
public UnionFind_QU_S(int capacity) {
super(capacity);
sizes = new int[capacity];
for (int i = 0; i < sizes.length; i++) {
sizes[i] = 1; //初始化每棵树的节点数量都为1
}
}
/**
* 矮的树嫁接到高的树上
*/
@Override
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if(p1 == p2) return ;
/**
* 判断哪个元素所在的集合树的节点数量比较少, 那么就将该树嫁接到节点数量较多的树上
*/
if(sizes[p1] > sizes[p2]){
parents[p2] = p1;
sizes[p1] = sizes[p1] + sizes[p2];
}else{
parents[p1] = p2;
sizes[p2] = sizes[p2] + sizes[p1];
}
}
}基于size的优化，也可能会存在树不平衡的问题
Quick Union – 基于rank的优化
package com.lic.UnionFind;
/**
* Quick Union 基于rank的优化
*/
public class UnionFind_QU_R extends UnionFind_QU{
private int[] ranks;
public UnionFind_QU_R(int capacity) {
super(capacity);
ranks = new int[capacity];
for (int i = 0; i < ranks.length; i++) {
ranks[i] = 1; //初始化每棵树的高度都为1
}
}
/**
* 矮的树嫁接到高的树上
*/
@Override
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if(p1 == p2) return ;
/**
* 判断哪个元素所在的集合树比较矮, 那么就将该树嫁接到较高的树上
* 如果两个树高度不同, 那么嫁接后, 两个树的高度都未发生改变
* 如果两个树的高度一致, 那么嫁接后, 矮的树高度不变, 高的树高度加 1
*/
if(ranks[p1] > ranks[p2]){
parents[p2] = p1;
}else if(ranks[p2] > ranks[p1]) {
parents[p1] = p2;
}else{
parents[p1] = p2;
ranks[p2] ++;
}
}
}
路径压缩（Path Compression）
虽然有了基于rank的优化，树会相对平衡一点, 但是随着Union次数的增多，树的高度依然会越来越高, 导致find操作变慢，尤其是底层节点（因为find是不断向上找到根节点）
路径压缩: 在find时使路径上的所有节点都指向根节点，从而降低树的高度
/**
* 在find过程, 将find路劲上的所有元素都指向根节点, 达到压缩路径的作用
*/
@Override
public int find(int v) {
rangeCheck(v);
if(v != parents[v]){
parents[v] = find(parents[v]); //获取到该元素的根节点,使该元素指向此根元素, 并返回该根元素
}
return parents[v];
}
路径压缩使路径上的所有节点都指向根节点，所以实现成本稍高,还有2种更优的做法，不但能降低树高，实现成本也比路径压缩低:路径分裂(Path Spliting), 路径减半(Path Halving); 路径分裂、路径减半的效率差不多，但都比路径压缩要好
路径分裂 (Path Spliting)
路径分裂：使路径上的每个节点都指向其祖父节点(parent的parent)
/**
* 在find过程, 使路径上的每个节点都指向其祖父节点
*/
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]){
int p = parents[v];
parents[v] = parents[parents[v]];
v = parents[v];
}
return v;
}路径减半（Path Halving）
路径减半：使路径上每隔一个节点就指向其祖父节点(parent的parent)
/**
* 在find过程, 使路径上每隔一个节点就指向其祖父节点
*/
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]){
parents[v] = parents[parents[v]];
v = parents[v];
}
return v;
}
并查集通用实现
public class GenericUnionFind<V> {
private Map<V, Node<V>> nodes = new HashMap<>();
public void makeSet(V v) {
if (nodes.containsKey(v)) return;
nodes.put(v, new Node<>(v));
}
/**
* 找出v的根节点
*/
private Node<V> findNode(V v) {
Node<V> node = nodes.get(v);
if (node == null) return null;
while (!Objects.equals(node.value, node.parent.value)) {
node.parent = node.parent.parent;
node = node.parent;
}
return node;
}
public V find(V v) {
Node<V> node = findNode(v);
return node == null ? null : node.value;
}
public void union(V v1, V v2) {
Node<V> p1 = findNode(v1);
Node<V> p2 = findNode(v2);
if (p1 == null || p2 == null) return;
if (Objects.equals(p1.value, p2.value)) return;
if (p1.rank < p2.rank) {
p1.parent = p2;
} else if (p1.rank > p2.rank) {
p2.parent = p1;
} else {
p1.parent = p2;
p2.rank += 1;
}
}
public boolean isSame(V v1, V v2) {
return Objects.equals(find(v1), find(v2));
}
private static class Node<V> {
V value;
Node<V> parent = this;
int rank = 1;
Node(V value) {
this.value = value;
}
}
}
性能测试
在20w随机数的数据规模下对以上7中并查集实现方式进行测试find和union方法, 测试结果如下:
【UnionFind_QF】
开始：20:28:55.041
结束：20:29:17.693
耗时：22.652秒
-------------------------------------
【UnionFind_QU】
开始：20:29:17.693
结束：20:30:26.599
耗时：68.906秒
-------------------------------------
【UnionFind_QU_R】
开始：20:30:26.602
结束：20:30:26.643
耗时：0.041秒
-------------------------------------
【UnionFind_QU_S】
开始：20:30:26.645
结束：20:30:26.685
耗时：0.04秒
-------------------------------------
【UnionFind_QU_R_PC】
开始：20:30:26.687
结束：20:30:26.721
耗时：0.034秒
-------------------------------------
【UnionFind_QU_R_PS】
开始：20:30:26.722
结束：20:30:26.755
耗时：0.033秒
-------------------------------------
【UnionFind_QU_R_PH】
开始：20:30:26.756
结束：20:30:26.787
耗时：0.031秒
-------------------------------------
2911
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
