12. 并查集（Union Find）

最新推荐文章于 2023-06-06 14:54:22 发布

含低调

最新推荐文章于 2023-06-06 14:54:22 发布

阅读量218

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/hanzong110/article/details/106160564

版权

数据结构与算法专栏收录该内容

21 篇文章 1 订阅

订阅专栏

1 并查集（Union Find）

并查集属于树形结构
假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路
设计一个数据结构，能够快速执行2个操作
1. 将两个村庄相连
2. 查询2个村庄之间是否有连接的路
3. 并查集能够办到查询、连接的均摊时间复杂度都是 O(α(n)) ，α (n) < 5
并查集非常适合解决这类“连接”相关的问题
并查集也叫作不相交集合（Disjoint Set）
并查集有2个核心操作
1. 查找（Find）：查找元素所在的集合(根节点)(这里的集合并不是特指Set这种数据结构，是指广义的数据集合)
2. 合并（Union）：将两个元素所在的集合合并为一个集合
2种常见的实现思路
1. Quick Find
  1. 查找（Find）的时间复杂度：O(1)
  2. 合并（Union）的时间复杂度：O(n)
2. Quick Union：常用
  1. 查找（Find）的时间复杂度：O(logn)，可以优化至O(α(n)) ，α (n) < 5
  2. 合并（Union）的时间复杂度：O(logn)，可以优化至O(α(n)) ，α (n) < 5
并查集可以通过数组实现，也可以通过链表实现

2 利用数组实现并查集

假设并查集处理的数据都是整型，那么可以用整型数组来存储数据
数组下标为并查集存储的元素值，下标对应的数组元素值表示并查集中存储的元素的父节点值
同一根节点下内容，就表示属于同一个集合。元素和索引相同，就说明其就是根节点
因此，并查集是可以用数组实现的树形结构（二叉堆、优先级队列也是可以用数组实现的树形结构）
接口设计

package com.mj.union;

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

3 Quick Find

Quick Find – Union(v1,v2)：让 v1 所在集合的所有元素都指向 v2 的根节点，时间复杂度O(n)。相当于所有人都当新帮派帮主小弟
Quick Find – Find：数组中的元素值，就是其根节点(也是父节点)，时间复杂度O(1)
UnionFind_QF

package com.mj.union;

/**
 * Quick Find
 * @author MJ Lee
 *
 */
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;
			}
		}
	}
}

4 Quick Union

Quick Union – Union(v1,v2)：让 v1 的根节点的父节点指向 v2 的根节点。相当于老帮派大哥，当新帮派大哥的小弟
Quick Union – Find：找传入节点的父节点，并一直向上找，直到找到根节点(根节点的父节点还是自身)
UnionFind_QU

package com.mj.union;

/**
 * Quick Union
 * @author MJ Lee
 *
 */
public class UnionFind_QU extends UnionFind {

	public UnionFind_QU(int capacity) {
		super(capacity);
	}

	/**
	 * 通过parent链条不断地向上找，直到找到根节点
	 */
	public int find(int v) {
		rangeCheck(v);
		while (v != parents[v]) {
			v = parents[v];
		}
		return v;
	}

	/**
	 * 将v1的根节点嫁接到v2的根节点上
	 */
	public void union(int v1, int v2) {
		int p1 = find(v1);
		int p2 = find(v2);
		if (p1 == p2) return;
		parents[p1] = p2;
	}

}

5 Quick Union优化

在Union的过程中，可能会出现树不平衡的情况，甚至退化成链表
2种常见的优化方案
1. 基于size的优化：元素少的树嫁接到元素多的树
2. 基于rank的优化：矮的树嫁接到高的树

5.1 基于size的优化

元素个数少的树，嫁接到元素个数多的树上
基于size的优化，也可能会存在树不平衡的问题
UnionFind_QU_S

package com.mj.union;

/**
 * Quick Union - 基于size的优化
 * @author MJ Lee
 *
 */
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];
		}
	}
}

5.2 基于rank的优化

将较矮的树嫁接到较高的树上
UnionFind_QU_R

package com.mj.union;

/**
 * Quick Union - 基于rank的优化
 * @author MJ Lee
 *
 */
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;
		}
	}
	
	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;
			//由于永远不会再用到p1的树高，所以虽然p1嫁接到了高的p2上，也没必要再更新p1高度成p2高度
		} else if (ranks[p1] > ranks[p2]) {
			parents[p2] = p1;
		} else {
			parents[p1] = p2;
			ranks[p2] += 1;
		}
	}
}

5.3 路径压缩（Path Compression）：leetcode上的标准做法

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

package com.mj.union;

/**
 * Quick Union - 基于rank的优化 - 路径压缩(Path Compression)
 * @author MJ Lee
 *
 */
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) { // v == 1, parents[v] == 2
  //        rangeCheck(v);
  //        if (parents[v] != v) {
  //            //原来右边为parents[v]，现改为find(parents[v])，意思将该元素与的父节点都改为原来的根节点
  //            parents[v] = find(parents[v]);
  //        }
  //        return parents[v];
  //    }
  //感觉上面递归的写法，其实不容易接受，不如这种while循环的方式来的自然，时间复杂度是一样的
  public int find(int index) {
    int indexTemp = index;
    //找到根节点
    while (index != parents[index]) {
      index = parents[index];
    }
    //路径上所有节点指向根节点
    while(indexTemp!=index){
      parents[indexTemp] = index;
      indexTemp = parents[indexTemp];
    }
    //返回根节点
    return index;
  }
}

实现成本稍高，还有2种更优的做法，不但能降低树高，实现成本也比路径压缩低
1. 路径分裂（Path Spliting）
2. 路径减半（Path Halving）

5.4 路径分裂（Path Spliting）

使路径上的每个节点都指向其祖父节点（parent的parent）
UnionFind_QU_R_PS

package com.mj.union;

/**
 * Quick Union - 基于rank的优化 - 路径分裂(Path Spliting)
 * @author MJ Lee
 *
 */
public class UnionFind_QU_R_PS extends UnionFind_QU_R {

	public UnionFind_QU_R_PS(int capacity) {
		super(capacity);
	}
	
	@Override
	public int find(int v) { 
		rangeCheck(v);
		while (v != parents[v]) {
			int p = parents[v];
			//只多了这一步，将v这个元素的父节点，改为原来其祖父节点
			parents[v] = parents[parents[v]];
			v = p;
		}
		return v;
	}
}

5.5 路径减半（Path Halving）

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

package com.mj.union;

/**
 * Quick Union - 基于rank的优化 - 路径减半(Path Halving)
 * @author MJ Lee
 *
 */
public class UnionFind_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 = parents[v];
		}
		return v;
	}
}

5.6 最佳实践

使用 Quick Union+基于 rank 的优化+Path Halving 或 Path Spliting
可以确保每个操作的均摊时间复杂度为O(α(n)) ，α (n) < 5

6 利用链表实现自定义类型的并查集

利用链表(标记父子关系)+Map(将数值与节点对应)实现
如果对象的唯一标识是int类型，可以直接用整数类型的并查集，不使用链表实现的通用的并查集
GenericUnionFind

package com.mj.union;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

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;
		//直接从path halving中拿来find代码进行修改即可
		//Objects.equals方法， 可以防止两个节点有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;
		}
	}
}

含低调

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
12. 并查集（Union Find）

1 并查集（Union Find）假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路设计一个数据结构，能够快速执行2个操作将两个村庄相连查询2个村庄之间是否有连接的路并查集能够办到查询、连接的均摊时间复杂度都是 O(α(n)) ，α (n) < 5并查集非常适合解决这类“连接”相关的问题并查集也叫作不相交集合（Disjoint Set）并查集有2个核心操作查找（Find）：查找元素所在的集合(根节点)(这里的集合并不是特指Set这种数据结构，是指广义的数据
复制链接

扫一扫

专栏目录