title: Day34-数据结构与算法-并查集
date: 2020-12-14 17:59:00
author: 子陌
常用的经典数据结构
- 假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路
-
设计一个数据结构，能够快速执行2个操作
- 查询2个村庄之间是否有连接的路
- 连接2个村庄
-
数组、链表、平衡二叉树、集合(Set)？
- 查询、连接的时间复杂度都是：O(n)
-
并查集能够办到查询、连接的均摊时间复杂度都是O(α(n))，α(n) < 5
-
并查集非常适合解决这类“连接”相关的问题
并查集（Union Find）
- 并查集也叫做不相交集合（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
- Quick Find
如何存储数据
- 假设并查集处理的数据都是整型，那么可以用整型数组来存储数据
- 因此，并查集是可以用数组实现的树形结构（二叉堆、优先级队列也是可以用数组实现的树形结构）
接口设计
int find(int v);查找v所属的集合（根节点）void union(int v1, int v2);合并v1、v2所属的集合boolean isSame(int v1, int v2);检查v1，v2是否属于同一个集合
初始化
- 初始化时，每个元素各自属于一个单元素集合
并查集公共抽象类抽取
package com.zimo.算法.并查集;
/**
* 并查集 - 公共抽象类抽取
*
* @author Liu_zimo
* @version v0.1 by 2020/12/15 10:16
*/
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 < 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是否属于同一个集合
* @return 返回检查结果
*/
public boolean isSame(int v1, int v2){
return find(v1) == find(v2);
}
protected void rangeCheck(int v){
if (v < 0 || v >= parents.length) throw new IllegalArgumentException("v is out of bounds");
}
}
Quick Find实现
- 合并时，将根节点涉及的所有子节点全部修改为新的根节点
package com.zimo.算法.并查集.QuickFind;
import com.zimo.算法.并查集.UnionFind;
/**
* 并查集 - Quick_Find
*
* @author Liu_zimo
* @version v0.1 by 2020/12/15 10:16
*/
public class QuickFind extends UnionFind {
public QuickFind(int capacity) {
super(capacity);
}
public int find(int v){
rangeCheck(v);
return parents[v];
}
/**
* 将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 Union实现
- 合并时，将根点的根节点修改为新的根节点
package com.zimo.算法.并查集.QuickUnion;
import com.zimo.算法.并查集.UnionFind;
/**
* 并查集 - Quick_Union
*
* @author Liu_zimo
* @version v0.1 by 2020/12/15 18:00
*/
public class QuickUnion extends UnionFind {
public QuickUnion(int capacity) {
super(capacity);
}
/**
* 通过parent链表不断地向上找，直到找到根节点
*/
@Override
public int find(int v) {
rangeCheck(v);
while (v != parents[v]){
v = parents[v];
}
return v;
}
/**
* 将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;
}
}
Quick Union优化
- 在Union的过程中，可能会出现树不平衡的情况，甚至退化成链表
- 有两种常见的优化方案
- 基于size 的优化：元素少的树 嫁接到 元素多的树
- 基于rank的优化：矮的树 嫁接到 高的书
- 基于size的优化，也可能会存在树的不平衡问题
基于size 的优化
package com.zimo.算法.并查集.QuickUnion;
/**
* 并查集 - Quick_Union - 基于size 的优化
* 元素少的树 嫁接到 元素多的树
*
* @author Liu_zimo
* @version v0.1 by 2020/12/16 10:33:50
*/
public class QuickUnion_Size extends QuickUnion {
private int[] sizes;
public QuickUnion_Size(int capacity) {
super(capacity);
sizes = new int[capacity];
for (int i = 0; i < capacity; i++) {
sizes[i] = 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[p1] = p2;
sizes[p2] += sizes[p1];
}else {
parents[p2] = p1;
sizes[p1] += sizes[p2];
}
}
}
基于rank的优化 荐
package com.zimo.算法.并查集.QuickUnion;
/**
* 并查集 - Quick_Union - 基于rank的优化
* 矮的树 嫁接到 高的书
*
* @author Liu_zimo
* @version v0.1 by 2020/12/16 10:52:48
*/
public class QuickUnion_Rank extends QuickUnion {
private int[] ranks;
public QuickUnion_Rank(int capacity) {
super(capacity);
ranks = new int[capacity];
for (int i = 0; i < capacity; i++) {
ranks[i] = 1;
}
}
@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;
}else if (ranks[p1] > ranks[p2]){
parents[p2] = p1;
}else {
parents[p1] = p2;
ranks[p2] += 1; // 如果两个树高一样，那么嫁接之后高度才会发生变化
}
}
}
1.路径压缩优化（Path Compression Question）
扫描二维码关注公众号，回复：
12890359 查看本文章
- 虽然有了基于rank的优化，树会相对平衡一点
- 但是随着Union次数的增多，树的高度依然会越来越高
- 导致find操作变慢，尤其是底层节点(因为find是不断向上找到根节点)
- 什么是路径压缩?
- 在find时使路径上的所有节点都指向根节点，从而降低树的高度
package com.zimo.算法.并查集.QuickUnion;
/**
* 并查集 - Quick_Union - 基于rank的优化 + 路劲压缩
*
* @author Liu_zimo
* @version v0.1 by 2020/12/16 10:52:48
*/
public class QuickUnion_RankPathCompression extends QuickUnion_Rank {
public QuickUnion_RankPathCompression(int capacity) {
super(capacity);
}
@Override
public int find(int v) {
rangeCheck(v);
if (parents[v] != v){
parents[v] = find(parents[v]);
}
return parents[v];
}
}
- 路径压缩使路径上的所有节点都指向根节点，所以实现成本稍高
- 还有两种更优的做法，不但能降低树高，实现成本也比路径压缩低
- 路径分裂
- 路径减半
- 路径分裂、路径减半的效率差不多，但都比路径压缩要好
2.路径分裂（Path Spliting）荐
- 路径分裂：使路径上的每个节点都指向其祖父节点（parent的parent）
package com.zimo.算法.并查集.QuickUnion;
/**
* 并查集 - Quick_Union - 基于rank的优化 + 路劲分裂
* 使路径上的每个节点都指向其祖父节点（parent的parent）
*
* @author Liu_zimo
* @version v0.1 by 2020/12/18 11:18:45
*/
public class QuickUnion_RankPathSpliting extends QuickUnion_Rank {
public QuickUnion_RankPathSpliting(int capacity) {
super(capacity);
}
@Override
public int find(int v) {
rangeCheck(v);
while (v != parents[v]){
int p = parents[v];
parents[v] = parents[parents[v]];
v = p;
}
return v;
}
}
3.路径减半（Path Halving）荐
- 路径减半：使路径上每隔一个节点就指向其祖父节点(parent的parent)
package com.zimo.算法.并查集.QuickUnion;
/**
* 并查集 - Quick_Union - 基于rank的优化 + 路劲减半
* 使路径上每隔一个节点就指向其祖父节点(parent的parent)
*
* @author Liu_zimo
* @version v0.1 by 2020/12/18 11:33:12
*/
public class QuickUnion_RankPathHalving extends QuickUnion_Rank {
public QuickUnion_RankPathHalving(int capacity) {
super(capacity);
}
@Override
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
如果是自定义类型，想使用并查集
- 方案1：自定类型转成整型后使用并查集（比如生成哈希值）
- 方案2：使用链表 + 映射（Map）
自定义并查集实现
package com.zimo.算法.并查集.QuickUnion;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
* 并查集 - 泛型（自定义类型）
*
* @author Liu_zimo
* @version v0.1 by 2020/12/19 12:01
*/
public class GenericUnionFind<V> {
private Map<V, Node<V>> nodes = new HashMap<>();
/**
* 初始化v
* @param v
*/
public void makeSet(V v){
if (nodes.containsKey(v)) return;
Node<V> vNode = new Node<>(v);
nodes.put(v, vNode);
}
public V find(V v){
Node<V> node = findNode(v);
return node == null ? null : node.value;
}
private Node<V> findNode(V v) {
Node<V> vNode = nodes.get(v);
if (vNode == null) return null;
// path Halving
while (!Objects.equals(vNode.value, vNode.parent.value)){
vNode.parent =vNode.parent.parent;
vNode = vNode.parent;
}
return vNode;
}
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;
public Node(V value) {
this.value = value;
}
}
}