数据结构 - 并查集（Union Find）

需求分析

• 假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路
  
• 设计一个数据结构，能快速执行2个操作

1. 查询2个村庄之间是否有连接的路
2. 连接2个村庄

• 数组、链表、平衡二叉树、集合(Set)？
  查询、链接的时间复杂度都是：O(n)
• 并查集能够办到查询、链接的均摊时间复杂度都是O(α(n))，α(n)<5
• 并查集非常适合解决这类“连接”相关的问题

并查集（Union Find）

• 并查集也叫不相交集合（Disjoint Set）
• 并查集有2个核心操作

1. 查找（Find）：查找元素所在的集合（这里的集合并不是特指Set这种数据结构，是指广义数据集合）
2. 合并（Union）：将两个元素所在的集合合并成为一个集合

• 有2种常见的实现思路

1. Quick Find
   查找（Find）的时间复杂度：O(1)
   合并（Union）的时间复杂度：O(n)
2. Quick Union
   查找（Find）的时间复杂度：O(logn)，可以优化至O(α(n))，α(n) < 5
   合并（Union）的时间复杂度：O(logn)，可以优化至O(α(n))，α(n) < 5

如何存储数据？

• 假设并查集处理的数据都是整形，那么可以用整形数组来存储数据
  
• 不难看出

1. 0、1、3属于同一集合
2. 2单独属于一个集合
3. 4、5、6、7属于同一集合

• 因此，并查集是可以用数组实现的树形结构（二叉堆、优先级队列也是可以用数组实现的树形结构）

接口定义

// 查找v所属的集合（根节点）
int find(int v);
// 合并v1、v2所属的集合
void union(int v1, int v2);
// 检查v1、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;
        }
    }
}

• 时间复杂度：O(n)

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

• 时间复杂度：O(1)

---

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;
}

• 时间复杂度：O(logn)

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

• 时间复杂度：O(logn)

---

Quick Union - 优化

• 在Union的过程中，可能会出现树不平衡的情况，甚至退化成链表
  
• 有2种常见的优化方案

1. 基于size的优化：元素少的树嫁接到元素多的树
2. 基于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中更有的做法，但不能降低树高，实现成本也比路径压缩低

1. 路径分裂（Path Spliting）
2. 路径减半（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
• 个人建议的搭配

1. Quick Union
2. 基于rank的优化
3. Path Halving 或 Path Spliting

---

自定义类型

• 之前的使用都是基于整形数据，如果其他自定义类型也想使用并查集呢？

1. 方案一：通过一些方法将自定义类型转为整形后使用并查集（比如生成哈希值）
2. 方案二：使用链表+映射（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));
    }
    // 找到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），就可以直接使用整数并查集