需求分析
- 假设有n个村庄,有些村庄之间有连接的路,有些村庄之间并没有连接的路
- 设计一个数据结构,能快速执行2个操作
- 查询2个村庄之间是否有连接的路
- 连接2个村庄
- 数组、链表、平衡二叉树、集合(Set)?
查询、链接的时间复杂度都是:O(n)
- 并查集能够办到查询、链接的均摊时间复杂度都是O(α(n)),α(n)<5
- 并查集非常适合解决这类“连接”相关的问题
并查集(Union Find)
- 并查集也叫不相交集合(Disjoint Set)
- 并查集有2个核心操作
- 查找(Find):查找元素所在的集合(这里的集合并不是特指Set这种数据结构,是指广义数据集合)
- 合并(Union):将两个元素所在的集合合并成为一个集合
- 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属于同一集合
- 因此,并查集是可以用数组实现的树形结构(二叉堆、优先级队列也是可以用数组实现的树形结构)
接口定义
int find(int v);
void union(int v1, int v2);
boolean isSame(int v1, int v2);
public boolean isSame(int v1, int v2) {
return find(v1) == find(v2);
}
初始化
- 初始化时,每个元素各自属于一个单元素集合
private int[] parents;
public UnionFind(int capacity) {
if (capacity < 0) {
throw new IllegalArgumentException("Capacity must >= 1.");
}
parents = new int[capacity];
for (int i = 0; i < parents.length; i++) {
parents[i] = i;
}
}
Quick Find - Union
- Quick Find 的union(v1, v2):让v1所在集合的所有元素都指向v2的根节点
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if (p1 == p2) return;
for (int i = 0; i < parents.length; i++) {
if (parents[i] == p1) {
parents[i] = p2;
}
}
}
Quick Find - Find
public int find(int v) {
rangeCheck(v);
return parents[v];
}
find(0) == 2
find(1) == 2
find(3) == 4
find(2) == 2
Quick Union - Union
- Quick Union的union(v1, v2):让v1的根节点指向v2的根节点
public void union(int v1, int v2) {
int p1 = find(v1);
int p2 = find(v2);
if (p1 == p2) return;
parents[p1] = p2;
}
Quick Union - Find
public int find(int v) {
rangeCheck(v);
while (v != parents[v]) {
v = parents[v];
}
return v;
}
find(0) == 2
find(1) == 2
find(3) == 2
find(2) == 2
Quick Union - 优化
- 在Union的过程中,可能会出现树不平衡的情况,甚至退化成链表
- 有2种常见的优化方案
- 基于size的优化:元素少的树嫁接到元素多的树
- 基于rank的优化:矮的树嫁接到高的树
Quick Union - 1.基于size的优化
sizes = new int[capacity];
for (int i = 0; i < sizes.length; i++) {
size[i] = 1;
}
private int[] sizes;
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[p1] = p2;
sizes[p2] += sizes[p1];
} else {
parents[p2] = p1;
sizes[p1] += sizs[p2];
}
}
- 基于size的优化,也可能会存在树不平衡的问题
Quick Union - 2.基于rank的优化
ranks = new int[capacity];
for (int i = 0; i < ranks.length; i++) {
ranks[i] = 1;
}
private int[] ranks;
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;
} else if (ranks[p2] < ranks[p1]) {
parents[p2] = p1;
} else {
parents[p1] = p2;
ranks[p2]++;
}
}
压缩路径(Path Compression)
- 虽然有了基于rank的优化,树会相对平衡一点
- 但是随着Union次数的增多,树的高度依然会越来越高,导致find操作变慢,尤其是底层节点(因为find是不断向上找到根节点)
- 什么是路径压缩?
- 在find时使路径上的所有节点都指向根节点,从而降低树的高度
public int find(int v) {
rangeCheck(v);
if (parents[v] != v) {
parents[v] = find (parents[v]);
}
return parents[v];
}
- 路径压缩使路径上的所有节点都指向根节点,所以实现成本稍高
- 还有2中更有的做法,但不能降低树高,实现成本也比路径压缩低
- 路径分裂(Path Spliting)
- 路径减半(Path Halving)
- 路径分裂、路径减半的效率差不多,但是都比路径压缩要好
1.路径分裂(Path Spliting)
- 路径分裂:使路径上的每个节点都指向其祖父节点(parent的parent)
public int find(int v) {
rangeCheck(v);
while (v != parents[v]) {
int parent = parents[v];
parents[v] = parents[parent];
v = parent;
}
return v;
}
2.路径减半(Path Halving)
- 路径减半:是路径上每隔一个节点就指向其祖父节点(parent的parent)
public int find(int v) {
rangeCheck(v);
while (v != parents[v]) {
parents[v] = parents[parents[v]];
v = parents[v];
}
return v;
}
总结
- 大概意思是:
- 使用路径压缩、分裂或减半+基于rank或者size的优化
可以确保每个操作的均摊时间复杂度为O(α(n)),α(n) < 5
- 个人建议的搭配
- Quick Union
- 基于rank的优化
- Path Halving 或 Path Spliting
自定义类型
- 之前的使用都是基于整形数据,如果其他自定义类型也想使用并查集呢?
- 方案一:通过一些方法将自定义类型转为整形后使用并查集(比如生成哈希值)
- 方案二:使用链表+映射(Map)
GenericUnionFind<Student> uf = new GenericUnionFind<>();
Student stu1 = new Student(10, "jack");
Student stu2 = new Student(18, "rose");
uf.makeSet(stu1);
uf.makeSet(stu2);
uf.union(stu1, stu2);
uf.isSame(stu1,sut2);
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));
}
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;
}
}
}
泛型的并查集,效率会低一点,时间是整数并查集的两倍,但是换来的是通用性,如果自定义对象有唯一标示(例如id),就可以直接使用整数并查集