1. 为什么会有并查集?并查集做啥用的?
假设有n个村庄,有些村庄之间有连接的路,有些村庄之间没有:
设计一个数据结构,能够快速执行2个操作
- 查询2个村庄之间是否有连接的路
- 连接2个村庄
对于上面这两个需求,可以用我们已知的一些数据结构进行完成(数组、链表、平衡二叉树、集合),比如用一个数组维护所有有连接的村庄。不过这样查询find和连接union的时间复杂度都为O(n)级别的。
- 而并查集就是专门做这两件事的数据结构:“并”union 和 “查” find
- 并且其查询、连接的均摊时间复杂度最佳可优化到O(α(n)),α(n)<5
2. union set简要介绍
并查集也叫做不相交集合 Disjoint Set,其包括两个核心操作:
- 查找 find : 查找两个元素所在的集合(这里的集合并不是特指Set这种数据结构,而是指广义上的)
- 合并 Union:将两个元素所在的集合合并为一个集合
有两种常见的实现思路:
- Quick Find
- 查找 find 的时间复杂度;O(1)
- 合并 Union 的时间复杂度: O(n)
- Quick Union
- 查找(Find) 的时间复杂度: O(logn), 可以优化至0( α(n), α (n) < 5
- 合并(Union) 的时间复杂度:O(logn), 可以优化至0( α(n), α (n) < 5
3. union set 存储形式
如果并查集处理的数据都是整型,那么可以用整型数组来存储数据。
我们用parents[] 数组存储,其中parents[i]
表示i号元素的父节点的下标。 那么如何看他们是不是属于一个集合呢? 看他们属是否具有相同的根节点。也就是说,一棵树表示一个集合。
因此,并查集是可以用数组实现的树形结构(二叉堆、优先级队列也是可以用数组实现的树形结构)
4.接口定义
/*
查找v所属的集合,返回根节点
*/
int find(int v);
/*
合并v1,v2所属的集合
*/
void union(int v1, int v2);
/*
检查v1,v2是否属于同一个集合,即查看根节点是否相同
*/
boolean isSame(int v1,int v2){
return find(v1) == find(v2);
}
5. 初始化
- 初始化时,每个元素各自属于一个单元集合
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];
for(int i = 0 ; i < capacity ; i ++)
parents[i] = i;
}
...
6. Quick Find 模式的实现
- union(a,b) 我们规定是将左边a的父节
parent[a]
点改为右边b的父节点parent[b]
- 注意在上述 union(1,2) 中, 1的父节点是0. 同时0 的父节点也是0, 因此在将1的父节点置为2时, 也得把0的父节点也置为2。因此,我们在实现中,会遍历数组,去寻找那些和1有着相同的父节点的元素,将它们统一换成新的父节点(这也是为啥quick find型union操作复杂度为O(n))
我们发现,这种流程下来,数组里面存着的元素都是根节点,因此find函数直接返回parentsp[v]
.
也就是像上图那样,这棵树很扁(高度最多为2)
这样就很能体现其find快的优势,因为其父节点就是该集合的根节点,直接存在parents[i]
当中,如上图中:
- find(0) = 2
- find(1) = 2
- find(3) = 3
- 时间复杂度: O(1)
步骤在前面已经讲明,那么代码如何实现的呢?
下面是quick find 模式的并查集数据结构:
- 并查集公共抽象基类,用于定义一些公共操作和函数
/**
* 并查集抽象基类
* @author lowfree
*
*/
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];
for(int i = 0 ; i < capacity ; i ++)
parents[i] = i;
}
/**
* 查找所属于的集合,返回根节点
* @param v
* @return
*/
public abstract int find(int v) ;
protected void rangeCheck(int v) {
if(v < 0 || v > parents.length)
throw new IllegalArgumentException("v should in the range of capactiy!");
}
/**
* 检查v1和v2是否属于相同集合,即检查根节点是否相等
* @param v1
* @param v2
* @return
*/
public boolean isSame(int v1 , int v2) {
return find(v1) == find(v2);
}
/**
* 合并两个集合,规定是将左边的置到右边的集合中
* @param v1
* @param v2
*/
public abstract void union(int v1 , int v2);
}
- 下面是刚刚介绍的quick find 模式的实现:
/**
* 并查集 quick find
* @author lowfree
*/
public class UnionFind_QF extends UnionFind{
public UnionFind_QF(int capacity) {
super(capacity);
}
/*
父节点就是根节点
*/
//O(1)
public int find(int v) {
rangeCheck(v);
return parents[v];
}
/*
将v1所在集合的所有元素,一个一个地嫁接到v2的父节点去
*/
//O(n)
public void union(int v1 , int v2) {
int p1 = parents[v1];
int p2 = parents[v2];
//本来就是一个集合了
if(p1 == p2) return;
parents[v1] = p2;
for(int i = 0 ; i < parents.length ; i ++) {
if(parents[i] == p1)
parents[i] = p2;
}
}
7. Quick Union
7.1 union(a,b)
合并操作步骤:找到两个根节点, 我们规定将左边a的根节点 “指向”(的父节点置为) 右边b的根节点
相比前面的quick find 模式
- 这一次我们是将左边根节点的父节点置为右边的父节点。所以在实现中,我们需要向上地去找到根节点。
- 同时,我们不需要再像前面一样去找那些具有相同父节点的元素,因为整个根节点都作为了右边结点的子节点,集合原封不动搬了过去
7.2 find 操作
find操作需要不断地循环往上找根节点
- find(0) = 2
- find(1) = 2
- find(4) = 2
这种情况下,那么代码如何实现的呢?
/**
* 并查集 quick union
* @author lowfree
*
*/
public class UnionFind_QU extends UnionFind{
public UnionFind_QU(int capacity) {
super(capacity);
// TODO Auto-generated constructor stub
}
/*
通过parent链条不断地向上找
*/
//O(logn)
@Override
public int find(int v) {
rangeCheck(v);
//不断向上地去找根节点
while(v != parents[v])
v = parents[v];
return v;
}
/*
将v1的根节点嫁接到v2的根节点上
*/
//O(logn)
@Override
public void union(int v1, int v2) {
//左边根节点
int p1 = find(v1);
//右边根节点
int p2 = find(v2);
if(p1 == p2) return;
//左边根节点的父节点变为右边根节点
parents[p1] = p2;
}
}
7.3 小结一下呗:
首先两个函数:
find(v)
: 寻找出v所在集合,即寻找v的根节点union(v1,v2)
:将v1,v2所在集合连接起来
然后两个模式
- 对于Quick-Find:
find(v)
:寻找根节点即是父节点,所以直接返回parent[v]
即可union(v1,v2)
:将v1所在集合中的所有元素,一个一个地嫁接到v2所指的父节点上去
- 对于Quick-Union:
find(v)
: 不断地向上连接去找根节点union(v1,v2)
:将v1的根节点直接嫁接到v2的根节点上去
8. Quick Union 优化
在Union的过程中,可能会出现树不平衡的情况,甚至退化成链表
有2种常见的优化方案
- 基于size的优化: 元素少的树嫁接到元素多的树
- 基于rank的优化: 矮的树嫁接到高的树
8.1基于Size的优化:需要一个sizes数组维护各个集合的size大小
/**
* 并查集 quick union
* 基于Size的优化
* @author lowfree
*
*/
public class UnionFind_QU_S extends UnionFind_QU{
private int[] sizes; //维护集合大小的数组
public UnionFind_QU_S(int capacity) {
super(capacity);
sizes = new int[capacity]; //初始化时,各个集合的size都为1
for(int i = 0 ; i < sizes.length; i ++)
sizes[i] = 1;
}
//find函数不变
@Override
public int find(int v) {
rangeCheck(v);
//通过parent链条不断地向上找
while(v != parents[v])
v = parents[v];
return v;
}
//O(logn)
@Override
public void union(int v1, int v2) {
//左边根节点
int p1 = find(v1);
//右边根节点
int p2 = find(v2);
if(p1 == p2) return;
//将size小的集合嫁接到大的集合根节点上
if(sizes[p1] <sizes[p2]) {
parents[p1] = p2;
sizes[p2] += sizes[p1];
}else {
parents[p2] = p1;
sizes[p1] += sizes[p2];
}
}
}
8.2 基于rank的优化: 需要维护集合的高度:
ranks数组,每次将矮的树嫁接到高的上面去
union(1,4) :
/**
* 并查集 quick union
* 基于Rank的优化
* @author lowfree
*
*/
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;
}
//find函数不变
@Override
public int find(int v) {
rangeCheck(v);
//通过parent链条不断地向上找
while(v != parents[v])
v = parents[v];
return v;
}
//将v1所在集合的所有元素都嫁接到v2上
//O(logn)
@Override
public void union(int v1, int v2) {
//左边根节点
int p1 = find(v1);
//右边根节点
int p2 = find(v2);
if(p1 == p2) return;
if(ranks[p1] < ranks[p2]) {
parents[p1] = p2;
//这里不需要对ranks改动
}else if(ranks[p2] < ranks[1]) {
parents[p2] = p1;
}else { //两树一样高
parents[p1] = p2;
ranks[p2] ++; //此时高度会加1
}
}
}
9.路径压缩path Compression
/**
* 并查集 quick union
* 基于Rank的优化
* 路径压缩
* @author lowfree
*
*/
public class UnionFind_QU_R_PC extends UnionFind_QU_R{
public UnionFind_QU_R_PC(int capacity) {
super(capacity);
}
@Override
public int find(int v) {
rangeCheck(v);
if(parents[v] != parents[v]) {
parents[v] = find(parents[v]);
}
return parents[v];
}
//union不变
}
- 路径压缩使得路径上所有节点都指向根节点,所以实现成本稍高
- 还有2种更优的做法,但不能降低树高,实现成本部也比路径压缩低
10. 路径分裂 Path Spliting
路径分裂:使路径.上的每个节点都指向其祖父节点(parent的parent)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u2hrKsLL-1590674681455)(union set.assets/image-20200528214325616.png)]
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]) {
int p = parents[v]; //先要保存一下其父亲,否则等下节点丢失
parents[v]= parents[parents[v]]; //v指向祖父节点
v = p;
}
return parents[v];
}
11.路径减半
路径减半:使路径上每隔一个节点就指向其祖父节点(parent的parent)
/**
* 并查集 quick union
* 基于Rank的优化
* 路径分裂
* @author lowfree
*
*/
public class UnionFind_QU_R_PH extends UnionFind_QU_R{
public UnionFind_QU_R_PH(int capacity) {
super(capacity);
// TODO Auto-generated constructor stub
}
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]) {
parents[v]= parents[parents[v]]; //v指向祖父节点
v = parents[v]; //v 变为它的祖父节点
}
return parents[v];
}
//union不变
}
11. 小结
使用路径压缩,分裂或减半 + 基于rank或者size的优化可以确保每个操作的均摊时间复杂度为O(α(n)),α(n)<5
建议的搭配
- Quick Union
- 基于rank的优化
nionFind_QU_R_PH extends UnionFind_QU_R{
public UnionFind_QU_R_PH(int capacity) {
super(capacity);
}
@Override
public int find(int v) {
rangeCheck(v);
while(v != parents[v]) {
parents[v]= parents[parents[v]]; //v指向祖父节点
v = parents[v]; //v 变为它的祖父节点
}
return parents[v];
}
//union不变
}