数据结构--并查集（十四）

以下是学习恋上数据结构与算法的记录，本篇主要内容是并查集

需求分析
假设有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𝛼𝑛，α(𝑛)<5
✓合并（Union）的时间复杂度：O(logn)，可以优化至O𝛼𝑛，α(𝑛)<5

如何存储数据？
假设并查集处理的数据都是整型，那么可以用整型数组来存储数据

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

接口定义

初始化
初始化时，每个元素各自属于一个单元素集合

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];
		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);
	}
	protected void rangeCheck(int v) {
		if(v<0 ||v>=parents.length) {
			throw new IllegalArgumentException("v is out of bounds");
		}
	}
}

Quick Find_QF

Quick Find –Union
合并v1、v2所在的集合Quick Find 的union(v1, v2)：让v1 所在集合的所有元素都指向v2 的根节点union(3, 4)

Quick Find –Find
查找元素所属的根节点：从结构上看，直接返回对应数组元素即可

public class UnionFind_QF extends UnionFind{
	public UnionFind_QF(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 _QU

Quick Union –Union
合并v1、v2所在的集合Quick Union 的union(v1, v2)：让v1 的根节点指向v2 的根节点

Quick Union –Find
查找元素所属的根节点：需要依靠指向父节点链寻找根节点

public class UnionFind_QU extends UnionFind {
@Override
	public int find(int v) {
		rangeCheck(v);
		while(v!=parents[v]) {
			v=parents[v];
		}
		return v;
	}
	@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的过程中，可能会出现树不平衡的情况，甚至退化成链表

●有2种常见的优化方案
✓基于size的优化：元素少的树嫁接到元素多的树
✓基于rank的优化：矮的树嫁接到高的树

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;
		}
	}
	/**
	 * 元素少的树嫁接到元素多的树
	 * 将v1的根节点嫁接到v2的根节点上
	 */
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];
		}
	}

基于size的优化，也可能会存在树不平衡的问题

Quick Union –基于rank的优化
rank树的高度低加入到树高的，高度不变，如果高度一样，则默认左嫁接右，高度加1。

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
		}
	}
	/*
	 * 树高度低加入到树高的，高度不变
	 * 如果高度一样，则默认左嫁接右，高度加1
	 */
	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;
		}
	}

路径压缩（Path Compression）
虽然有了基于rank的优化，树会相对平衡一点，但是随着Union次数的增多，树的高度依然会越来越高，导致find操作变慢，尤其是底层节点（因为find是不断向上找到根节点）
●什么是路径压缩？
在find时使路径上的所有节点都指向根节点，从而降低树的高度

public int find(int v) {// v == 1, parents[v] == 2
		rangeCheck(v);
		if (v != parents[v]) {
			parents[v] = find(parents[v]);
		}
		return parents[v];
	}

路径压缩使路径上的所有节点都指向根节点，所以实现成本稍高

●还有2种更优的做法，不但能降低树高，实现成本也比路径压缩低
✓路径分裂（Path Spliting）
✓路径减半（Path Halving）
路径分裂、路径减半的效率差不多，但都比路径压缩要好

路径分裂（Path Spliting）
使路径上的每个节点都指向其祖父节点（parent的parent）

public int find(int v) {
		rangeCheck(v);
		while(v !=parents[v]) {
			int p = parents[v];//保存父节点
			parents[v] = parents[parents[v]];//指向祖父节点
			v =p;//把父节点赋值给V 使其同样进行此操作
		}
		return v;
	}

路径减半（Path Halving）
使路径上每隔一个节点就指向其祖父节点（parent的parent）

public int find(int v) {
		rangeCheck(v);
		while(v != parents[v] ) {
			parents[v] = parents[parents[v]];//指向祖父节点
			v = parents[v];//把祖父节点值赋值给V 跳过父节点
		}
		return v;
	}

使用路径压缩、分裂或减半+ 基于rank或者size的优化
✓可以确保每个操作的均摊时间复杂度为O𝛼𝑛，α(𝑛)<5
●个人建议的搭配
✓Quick Union
✓基于rank 的优化
✓Path Halving 或Path Spliting

自定义类型
之前的使用都是基于整型数据，如果其他自定义类型也想使用并查集呢？
方案一：通过一些方法将自定义类型转为整型后使用并查集（比如生成哈希值）
方案二：使用链表+映射（Map）

方案一代码

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;//Objects.equals方法包含判断是否为空
		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;//value值
		Node<V> parent= this;//父节点并且初始化
		int rank =1;//树的高度
		public Node(V value) {//构造方法
			this.value = value;
		}
		
	}
}