【并查集】Union Find

最新推荐文章于 2022-08-16 20:17:53 发布
最新推荐文章于 2022-08-16 20:17:53 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： # 《恋上数据结构》 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43734095/article/details/105180239
版权

并查集

引出并查集

假设有 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

如何存储数据？

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

  • 数组索引代表元素值
  • 索引对应的值代表这个元素的根节点

将｛0，1，2，3，4，5，6，7｝存储到数组中，如下图：
在这里插入图片描述

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

接口定义

/**
 * 查找v所属的集合(根结点)
 */
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);

isSame() 的实现十分简单：

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

UnionFind.java

这是个并查集的抽象类，后面的所有并查集都将继承它。

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所属的集合(根结点)
	 */
	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

Quick Find 的 union(v1, v2)：让 v1 所在集合的所有元素都指向 v2 的根节点。
并且 Quick Find 的高度永远保持 <= 2。

union 示例及实现

例如：
将｛0，1，2，3，4，5｝初始化为并查集，每个元素各自属于一个单元素集合：{0}, {1}, {2}, {3}, {4} 。
在这里插入图片描述
合并 1 和 0，union(1, 0)，即 {1} 指向了 {2} 。
在这里插入图片描述
然后，合并 1 和 2，union(1, 2)，1 所在集合有 {0, 1}，即 {0, 1} 指向了 2 。
在这里插入图片描述
再合并 3 和 4，union(3, 4)，即 {3} 指向了 {4} 。
在这里插入图片描述
合并 0 和 3，union(0, 3)，0 所在集合为 {0, 1, 2}，3 所在集合为 {3,4}，如下：
在这里插入图片描述

/**
 * 将v1所在集合的所有元素都嫁接到v2的父节点上
 * v1    v2   union(v1,v2)
 *  0    4	     4
 * 1 2   3     0 1 2 3
 */
public void union(int v1, int v2){
	int p1 = parents[v1];
	int p2 = parents[v2];
	
	for (int i = 0; i < parents.length; i++) {
		if(parents[i] == p1){
			parents[i] = p2;
		}
	}
}

union 时间复杂度：O(n)

find 实现

Quick Find 查找的时候，由于数组中存储的就是根结点，因此直接取出即可。
在这里插入图片描述

对上图执行 find():
find(0) == 2
find(1) == 2
find(2) == 2
find(3) == 4

/**
 * 父节点就是根节点
 */
public int find(int v){
	rangeCheck(v);
	return parents[v];
}

find 时间复杂度：O(1)

Quick Find 完整代码

package com.mj.union;

/**
 * Quick 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的父节点上
	 * v1    v2   union(v1,v2)
	 *  0    4	     4
	 * 1 2   3     0 1 2 3
	 */
	public void union(int v1, int v2){
		int p1 = parents[v1];
		int p2 = parents[v2];
		
		for (int i = 0; i < parents.length; i++) {
			if(parents[i] == p1){
				parents[i] = p2;
			}
		}
	}
	
}

Quick Union

Quick Find 的 union(v1, v2)：让 v1 所在集合的所有元素都指向 v2 的根节点。

Quick Union 的 union(v1, v2)：让 v1 的根节点指向 v2 的根节点 。(与Quick Find进行对比)

union 示例及实现

将｛0，1，2，3，4，5｝初始化为并查集，每个元素各自属于一个单元素集合。
在这里插入图片描述
union(1, 0) ，1的根结点(还是1) 指向 0的根结点(还是0)。
在这里插入图片描述

union(1, 2)，1的根结点(0) 指向 2的根结点(2)。
在这里插入图片描述
union(3, 4)，3的根结点(3) 指向 4的根结点(4)。
在这里插入图片描述
union(3, 1)，3的根结点(4) 指向 1的根结点(2)。
在这里插入图片描述

/**
 * 将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)

find 实现

Quick Union 的查找，需要通过父节点不断往上找，直到找到根结点（某节点的根结点为自己）。
在这里插入图片描述

对上图执行 find():
find(0) == 2
find(1) == 2
find(3) == 2
find(4) == 2

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

Quick Union 完整实现

package com.mj.union;

/**
 * Quick Union
 */
public class UnionFind_QU extends UnionFind {

	public UnionFind_QU(int capacity) {
		super(capacity);
	}
	/**
	 * 通过parent链条不断往上找，直到找到根节点
	 */
	@Override 
	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;
	}

}

Quick Union – 优化

一般用的更多的是 Quick Union，我们研究一下它的优化方案。

在 union 的过程中，可能会出现树不平衡的情况，甚至退化成链表。
在这里插入图片描述
有 2 种常见的优化方案：

  • 基于 size 的优化：元素少的树 嫁接到 元素多的树
  • 基于 rank 的优化：矮的树 嫁接到 高的树

Quick Union – 基于size的优化

不是固定的让某一棵树嫁接到另一棵树，让元素少的树 嫁接到 元素多的树。
在这里插入图片描述

该类继承了 UnionFind_QU，表明它是在 Quick Union 的基础上优化，并且只需要重写uniont(int v1, int v2)即可，find(int v)无需做任何变化。

package com.mj.union;

/**
 * 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];
		}
	}

}

Quick Union – 基于rank的优化

上面所说的，基于size的优化，也可能会存在树不平衡的问题。
在这里插入图片描述
基于rank的优化，让矮的树 嫁接到 高的树。
在这里插入图片描述

该类继承了 UnionFind_QU，表明它是在 Quick Union 的基础上优化，并且只需要重写uniont(int v1, int v2)即可，find(int v)无需做任何变化。

package com.mj.union;

/**
 * Quick Union - 基于rank的优化
 * @author yusael
 */
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 < parents.length; i++) {
			ranks[i] = 1;
		}
	}
	
	public void union(int v1, int v2){
		int p1 = find(v1);
		int p2 = find(v2);
		
		if(ranks[p1] < ranks[p2]){
			parents[p1] = p2;
		}else if(ranks[p1] > ranks[p2]){
			parents[p2] = p1;
		}else{ // ranks[p1] == ranks[p2]
			parents[p1] = p2;
			ranks[p2] += 1;
		}
	}

}

路径压缩（Path Compression）

虽然有了基于 rank 的优化，树会相对平衡一点，但是随着 union 次数的增多：树的高度依然会越来越高，导致 find 操作变慢，尤其是底层节点 (因为 find 是不断向上找到根节点) 。

什么是路径压缩？

  • 在 find 时使路径上的所有节点都指向根节点，从而降低树的高度。

如下图，

  • find(1) 使路径上的 1，2 都指向了根结点 4。
  • find(0) 使路径上的 0 指向了根结点 4。
  • find(7) 使路径上的 7 指向了根结点 4。在这里插入图片描述

该类继承了 UnionFind_QU_R，表明它是在 Quick Union 的 rank 优化的基础上，再优化，并且只需要重写find(int v)即可。

package com.mj.union;

/**
 * Quick Union - 基于rank的优化 - 路径压缩(Path Compression)
 * @author yusael
 */
public class UnionFind_QU_R_PC extends UnionFind_QU_R {

	public UnionFind_QU_R_PC(int capacity) {
		super(capacity);	
	}
	/**
	 * 在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）

路径分裂、路径减半的效率差不多，但都比路径压缩要好。

路径分裂（Path Spliting）

路径分裂：使路径上的每个节点都指向其祖父节点（parent的parent）。
在这里插入图片描述
该类继承了 UnionFind_QU_R，表明它是在 Quick Union 的 rank 优化的基础上，再优化，并且只需要重写find(int v)即可。

package com.mj.union;

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

	public UnionFind_QU_R_PS(int capacity) {
		super(capacity);
	}
	
	public int find(int v){
		rangeCheck(v);
		while(v != parents[v]){
			int p = parents[v];
			parents[v] = parents[parents[v]];
			v = p;
		}
		return parents[v];
	}
	
}

路径减半（Path Halving）

路径减半：使路径上每隔一个节点就指向其祖父节点（parent的parent）。
在这里插入图片描述
该类继承了 UnionFind_QU_R，表明它是在 Quick Union 的 rank 优化的基础上，再优化，并且只需要重写find(int v)即可。

package com.mj.union;

/**
 * Quick Union - 基于rank的优化 - 路径减半(Path Halving)
 */
public class UnionFind_QU_R_PH extends UnionFind_QU_R {

	public UnionFind_QU_R_PH(int capacity) {
		super(capacity);
	}
	
	public int find(int v){
		rangeCheck(v);
		while(v != parents[v]){
			parents[v] = parents[parents[v]];
			v = parents[v];
		}
		return v;
	}
	
}

时间测试

package com.mj;

public class Main {
	static final int count = 1000000;

	public static void main(String[] args) {
		// testTime(new UnionFind_QF(count)); // 太慢,不测
		// testTime(new UnionFind_QU(count)); // 太慢,不测
		testTime(new UnionFind_QU_S(count));
		testTime(new UnionFind_QU_R(count));
		testTime(new UnionFind_QU_R_PC(count));
		testTime(new UnionFind_QU_R_PS(count));
		testTime(new UnionFind_QU_R_PH(count));
	}
	static void testTime(UnionFind uf) {
		Times.test(uf.getClass().getSimpleName(), () -> {
			for (int i = 0; i < count; i++) {
				uf.union((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
			
			for (int i = 0; i < count; i++) {
				uf.isSame((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
		});
	}
}

在这里插入图片描述

总结

使用路径压缩、分裂或减半 + 基于rank或者size的优化可以确保每个操作的均摊时间复杂度为 O(𝛼(𝑛)) ，α(𝑛) < 5。

建议搭配：

  • Quick Union
  • 基于 rank 的优化
  • Path Halving 或 Path Spiliting

自定义类型使用并查集

  • 方案一：通过一些方法将自定义类型转为整型后使用并查集（比如生成哈希值）
  • 方案二：使用链表+映射（Map）

这里采用方案二实现：

package com.mj.union;

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

时间测试

package com.mj;

import com.mj.tools.Asserts;
import com.mj.tools.Times;
import com.mj.union.GenericUnionFind;
import com.mj.union.UnionFind;
import com.mj.union.UnionFind_QU_R;
import com.mj.union.UnionFind_QU_R_PC;
import com.mj.union.UnionFind_QU_R_PH;
import com.mj.union.UnionFind_QU_R_PS;
import com.mj.union.UnionFind_QU_S;

public class Main {
	static final int count = 10000000;

	public static void main(String[] args) {
//		testTime(new UnionFind_QF(count)); // 太慢了,不测试
//		testTime(new UnionFind_QU(count)); // 太慢了,不测试
		testTime(new UnionFind_QU_S(count));
		testTime(new UnionFind_QU_R(count));
		testTime(new UnionFind_QU_R_PC(count));
		testTime(new UnionFind_QU_R_PS(count));
		testTime(new UnionFind_QU_R_PH(count));
		testTime(new GenericUnionFind<Integer>());
	}
	
	static void testTime(GenericUnionFind<Integer> uf) {
		for (int i = 0; i < count; i++) {
			uf.makeSet(i);
		}
		
		Times.test(uf.getClass().getSimpleName(), () -> {
			for (int i = 0; i < count; i++) {
				uf.union((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
			
			for (int i = 0; i < count; i++) {
				uf.isSame((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
		});
	}
	
	static void testTime(UnionFind uf) {
		Times.test(uf.getClass().getSimpleName(), () -> {
			for (int i = 0; i < count; i++) {
				uf.union((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
			
			for (int i = 0; i < count; i++) {
				uf.isSame((int)(Math.random() * count), 
						(int)(Math.random() * count));
			}
		});
	}
}

GenericUnionFind 通用性是最强的，自然比之前的要慢一些。
在这里插入图片描述

萌宅鹿同学
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
数据结构基础_并查集（UnionFind）
coding
11-21 311
一. 认识并查集 可以高效的解决连接问题（Connectivity Problem） 检查网络中节点间的连接状态（网络是个抽象概念：用户之间形成的网络） 数学中的集合类实现（合并问题） 连接问题和路径问题：连接问题只需回答是或否，而路径问题要回答出具体的路径； 对于一组数据，并查集主要支持三个动作： union(p, q) -----------------并操作，将元素p,q并入同一个...
并查集Union Find
qq_48019875的博客
12-07 847
目录一、并查集解决什么问题？二、操作三、并查集的基本数据表示四、代码与合并操作五、真正的并查集实现六、数据表示七、测试并查集八、基于size的优化九、基于rank优化十、路径压缩十一、路径压缩的优化 一、并查集解决什么问题？ 可以非常高效的解决网络中节点的连接问题， 使用并查集，可以确定图中两个点是否有连接。 二、操作 （1）创建一个数组或集合 保存两个数 （2）合并 union （p，q） （3）是否连接 isConnection（p，q） 在使用并查集时，我们并不关心元素的内容，用数组保存元素，p和q
并查集算法（union-find）
夜夜夜夜
04-27 843
就动态连通性这个场景而言，我们需要解决的问题可能是： 给出两个节点，判断它们是否连通，如果连通，不需要给出具体的路径 给出两个节点，判断它们是否连通，如果连通，需要给出具体的路径就上面两种问题而言，虽然只有是否能够给出具体路径的区别，但是这个区别导致了选择算法的不同，本文主要介绍的是第一种情况，即不需要给出具体路径的Union-Find算法，而第二种情况可以使用基于DFS的算法。 题目1：畅通
UnionFind(并查集)
weixin_45730130的博客
08-16 416
基于C++的并查集数据结构的实现，一步步优化。可阅读性应该还可以。
并查集 Union Find
Bridge
03-02 144
并查集：在进行判断两个数据之间是不是有连接的操作中。如果我们单独用数组进行数据的存储，把有连接的数据的ID设置成相同的数字，那么这种数据结构进行查找操作的时候，时间复杂度是O（1），但是进行合并的时候，所进行的时间复杂度是O（n）。对于数据量较大的情况，O（n）将会是个非常慢的操作。所以这个时候需要并查集这种数据结构。这种数据结构更像是森林，每棵树上的数据是有连接的，不同树之间的数据是没有连接的。...
InterviewQuestion: Union–Find
sun%moon
12-01 333
Social network connectivity. Given a social network containing nn members and a log file containing mm timestamps at which times pairs of members formed friendships, design an algorithm to determine ...
并查集（Union-Find）介绍.zip
最新发布
04-12
并查集是一种在分散数据集中查找元素关联关系的数据结构，主要应用于处理一些不相交集合的合并与查询问题。在并查集中，每个元素属于一个集合，而集合之间可能存在或不存在连接关系。这个数据结构的核心操作是“查找...
数据结构—并查集UnionFind
sanmi8276的博客
01-29 191
原文作者：愚公要移山1 原文地址：一个非常实用而且精妙的算法-并查集（java语言实现） 在学习数据结构的时候，老师多少会提到并查集，他的应用也是超级广泛。本文首先会通过案例来对并查集有一个介绍。然后给出并查集的java实现。
并查集（UnionFind）
Debroon
11-25 555
并查集（UnionFind）基本介绍合并优化基于 Size 优化基于 Rank 优化基于路径压缩优化   基本介绍 并查集可以高效的回答，网络中任意的俩个点是否连接，因为只关心是否连接，不关心是怎么连接，所以没有做无用功。 所谓并查集（UnionFind），就是由俩种操作组合而成： 并：union 查：find 并查集也是树，不过不是父亲指向孩子，而是孩子指向父亲。 把每一个元素，看做是一个节点并且指向自己的父节点，根节点指向自己。 我们通过一个数组记录这份关系： 数组编号 0.
并查集（Union-Find）
小朱小朱绝不认输的博客
05-26 1187
并查集是一种巧妙的算法思想，主要解决连通性问题的场景，比如：一组对象被划分成了若干个区域，求解被划分区域的数量，或者求解如何将这几个区域连接起来。 文章目录1. 并查集（Union-Find）算法介绍1.1 动态连通性1.2 union-find算法API2 union-find的实现2.1 quick-find算法2.2 quick-union算法2.3 加权quick-union算法2.4 使用路径压缩的加权quick-union算法2.5 算法比较 1. 并查集（Union-Find）算法介绍 1.1
union find（自用）
llllleapfrog的博客
01-28 829
type unionfind struct { count int //连通分量数 parent []int } //初始化 //x的父节点指向自己 func InitUF(n int) *unionfind{ uf :=new(unionfind) uf.count = n uf.parent = make([]int,n) for i:=0;i<n;i++{ uf.parent[i] = i } return uf } //union func (u unionfin
并查集(Union-Find) (图文详解)
热门推荐
qq_57469718的博客
06-22 1万+
并查集 数据结构 算法 Leetcode
union-find问题
qq_43785212的博客
09-22 155
union-find算法实现 union-find问题就是动态图连通性问题，即图中两点是否连通。 加权quick-union算法 加权quick-union算法是解决union-find问题比较高效的办法，主要思想为： 同一连接分量的节点使用树进行连接，find()函数可以查找节点所在连接分量树的根节点，通过比较根节点是否相同来判断节点是否属于同一连通分量。 连接时如果两节点不在同一连通分量上则需要将两个连通分量并到同一棵树上，此处便是加权的思想：将节点数较小的树的根节点连接到节点数较大的根节点上，这样可使
图论基础之Union Find
圣·马坡岭皇家码农
08-09 420
Concept Union Find通常被翻译为并查集，让人听起来觉得非常高深莫测，为此，我给它起了个外号 叫做：“认祖宗”！ 没错，寻找根节点的过程难道不就叫“认祖宗”吗？ 我们可以把图论中的一些术语用日常生活用语联系起来： 节点：形形色色的人 边：父子关系 根：一群人的祖宗 并查集就是把一群人用一种算法分成不同家族。 其中一个重要的过程就是认亲。 所以，并查集有如下几个要素...
LeetCode 1319, 684, 685 union find
frankguodongchen的博客
04-15 78
LeetCode 1319 想要知道我们如何移动最少使得连通，联通需要的个数就是集合个数-1. 基本上就可以把这个题目转换为求集合的个数。那么通过union find找集合就比较容易了。因为本身是无向图，注意我们都让父节点朝一个方向走（最大或者最小） def makeConnected(self, n: int, connections: List[List[int]]) -> in...
union-find算法
Geek_sun的博客
08-13 192
quick-find算法 public class UF { private int[] id; //分量id private int count; //分量数量 public UF(int N){ count = N; id = new int[N]; for(int i = 0;i < N;i++){...
union-find算法（并查集）
li1358159的博客
02-14 898
任何一种算法都是为解决某个问题而生的，union-find是用于解决动态连通性问题的一种算法。
什么是Union Find(并查集)？
Tech in Pieces
12-06 234
并查集是一种属性数据结构 用于处理一些不交集disjoint sets的合并以及查询问题。 但是光这么说也太他妈抽象了。 不如看两个应用场景： 网络连接判断： 如果每个pair中的两个整数分别代表一个网络节点，那么该pair就是用来表示这两个节点是需要连通的。那么为所有的pairs建立了动态连通图后，就能够尽可能少的减少布线的需要，因为已经连通的两个节点会被直接忽略掉。 变量名等同性(类似于指针的概念)： 在程序中，可以声明多个引用来指向同一对象，这个时候就可以通过为程序中声明的引用和实际对象建立动态连通
并查集(Union-Find)粗略介绍
上千主上-贝库塔
08-08 1951
并查集 算法 数据结构
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萌宅鹿同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值