数据结构-非线性结构-树形结构：并查集（Union Find）【用于判断“网络”中节点间的连接状态】

已于 2022-07-12 19:05:20 修改
阅读量133 收藏
点赞数
文章标签： 数据结构 树形结构 并查集
于 2021-05-03 19:55:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013250861/article/details/116379968
版权

在这里插入图片描述

并查集的代码实现

接口文件：UnionFind.java

/**
 * 并查集
 *
 * @author whx
 * @version 2018/9/1
 */
public interface UnionFind {

	/**
	 * 获取并查集的大小
	 *
	 * @param
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	int getSize();

	/**
	 * 查询两个元素是否相连
	 *
	 * @param p
	 * @param q
	 * @return boolean
	 * @author whx
	 * @version 2018/9/1
	 */
	boolean isConnected(int p, int q);

	/**
	 * 将两个元素并在一起
	 *
	 * @param p
	 * @param q
	 * @return void
	 * @author whx
	 * @version 2018/9/1
	 */
	void unionElements(int p, int q);
}

1、版本01

UnionFind1.java

/**
 * 并查集
 * 第一个版本，Quick Find,数组模拟实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind1 implements UnionFind{

	private int[] id;//存储当前位置元素的id

	public UnionFind1(int size) {
		id = new int[size];
		for (int i = 0; i < size; i++) {
			id[i] = i;
		}
	}

	@Override
	public int getSize() {
		return id.length;
	}

	/**
	 * 查找元素p所对应的集合编号
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > id.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		return id[p];
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pId = find(p);
		int qId = find(q);
		if (pId == qId){
			return;
		}
		for (int i = 0; i < id.length; i++) {
			if(id[i] == pId){
				id[i] = qId;
			}
		}
	}
}

2、版本02

UnionFind2.java

/**
 * 并查集
 * 第二个版本，Quick Union,数组实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind2 implements UnionFind{

	private int[] parent;//存储当前位置元素的根节点

	public UnionFind2(int size) {
		parent = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的根节点
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > parent.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		while (p != parent[p]){
			p = parent[p];
		}
		return p;
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);
		if (pRoot == qRoot){
			return;
		}
		parent[pRoot] = qRoot;
	}
}

3、版本03

/**
 * 并查集
 * 第三个版本，基于size大小的优化,数组实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind3 implements UnionFind{

	private int[] parent;//存储当前位置元素的根节点
	private int[] quantity;//表示以当前元素为根节点的集合中元素个数

	public UnionFind3(int size) {
		parent = new int[size];
		quantity = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			quantity[i] = 1;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的根节点
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > parent.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		while (p != parent[p]){
			p = parent[p];
		}
		return p;
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);

		if (pRoot == qRoot){
			return;
		}

		//根据以当前元素为根节点的集合中元素个数的大小来合并
		//将以当前元素为根节点的集合中元素个数小的合并到大的集合上面
		if(quantity[pRoot] < quantity[qRoot]){
			parent[pRoot] = qRoot;
			quantity[qRoot] += quantity[pRoot];
		}else {
			parent[qRoot] = pRoot;
			quantity[pRoot] += quantity[qRoot];
		}
	}
}

4、版本04

UnionFind4.java

/**
 * 并查集
 * 第四个版本，基于rank大小的优化,数组实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind4 implements UnionFind{

	private int[] parent;//存储当前位置元素的根节点
	private int[] rank;//表示以当前元素为根节点的高度

	public UnionFind4(int size) {
		parent = new int[size];
		rank = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			rank[i] = 1;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的根节点
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > parent.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		while (p != parent[p]){
			p = parent[p];
		}
		return p;
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);

		if (pRoot == qRoot){
			return;
		}
		//根据以当前元素为根节点的高度来合并
		//将以当前元素为根节点的高度低的合并到高的集合上面
		if(rank[pRoot] < rank[qRoot]){
			parent[pRoot] = qRoot;
		}else if(rank[pRoot] > rank[qRoot]) {
			parent[qRoot] = pRoot;
		}else {
			parent[pRoot] = qRoot;
			rank[qRoot] += 1;
		}
	}
}

5、版本05

UnionFind5.java

/**
 * 并查集
 * 第五个版本，路径压缩优化,数组实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind5 implements UnionFind{

	private int[] parent;//存储当前位置元素的根节点
	private int[] rank;//表示以当前元素为根节点的高度

	public UnionFind5(int size) {
		parent = new int[size];
		rank = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			rank[i] = 1;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的根节点
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > parent.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		while (p != parent[p]){
			//路径压缩
			parent[p] = parent[parent[p]];
			p = parent[p];
		}
		return p;
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);

		if (pRoot == qRoot){
			return;
		}
		//根据以当前元素为根节点的高度来合并
		//将以当前元素为根节点的高度低的合并到高的集合上面
		if(rank[pRoot] < rank[qRoot]){
			parent[pRoot] = qRoot;
		}else if(rank[pRoot] > rank[qRoot]) {
			parent[qRoot] = pRoot;
		}else {
			parent[pRoot] = qRoot;
			rank[qRoot] += 1;
		}
	}
}

6、版本06

UnionFind6.java

/**
 * 并查集
 * 第六个版本，路径压缩优化,数组实现
 *
 * @author whx
 * @version 2018/9/1
 */
public class UnionFind6 implements UnionFind{

	private int[] parent;//存储当前位置元素的根节点
	private int[] rank;//表示以当前元素为根节点的高度

	public UnionFind6(int size) {
		parent = new int[size];
		rank = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			rank[i] = 1;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的根节点
	 *
	 * @param p
	 * @return int
	 * @author whx
	 * @version 2018/9/1
	 */
	private int find(int p){
		if(p < 0 || p > parent.length){
			throw new IllegalArgumentException("p is out of bound.");
		}
		//递归路径压缩
		if (p != parent[p]){
			parent[p] = find(parent[p]);
		}
		return parent[p];
	}

	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);

		if (pRoot == qRoot){
			return;
		}
		//根据以当前元素为根节点的高度来合并
		//将以当前元素为根节点的高度低的合并到高的集合上面
		if(rank[pRoot] < rank[qRoot]){
			parent[pRoot] = qRoot;
		}else if(rank[pRoot] > rank[qRoot]) {
			parent[qRoot] = pRoot;
		}else {
			parent[pRoot] = qRoot;
			rank[qRoot] += 1;
		}
	}
}

测试代码

Main.java

import java.util.Random;

/**
 * @author whx
 * @version 2018/9/1
 */
public class Main {

	public static void main(String[] args) {
		int n = 1000000;
		int size = 1000000;

		UnionFind1 unionFind1 = new UnionFind1(size);
		double testUnionFind1Time = testUnionFind(unionFind1, n);
		System.out.println("UnionFind1： "+testUnionFind1Time+" s");

		UnionFind2 unionFind2 = new UnionFind2(size);
		double testUnionFind2Time = testUnionFind(unionFind2, n);
		System.out.println("UnionFind2： "+testUnionFind2Time+" s");

		UnionFind3 unionFind3 = new UnionFind3(size);
		double testUnionFind3Time = testUnionFind(unionFind3, n);
		System.out.println("UnionFind3： "+testUnionFind3Time+" s");

		UnionFind4 unionFind4 = new UnionFind4(size);
		double testUnionFind4Time = testUnionFind(unionFind4, n);
		System.out.println("UnionFind4： "+testUnionFind4Time+" s");

		UnionFind5 unionFind5 = new UnionFind5(size);
		double testUnionFind5Time = testUnionFind(unionFind5, n);
		System.out.println("UnionFind5： "+testUnionFind5Time+" s");

		UnionFind6 unionFind6 = new UnionFind6(size);
		double testUnionFind6Time = testUnionFind(unionFind6, n);
		System.out.println("UnionFind6： "+testUnionFind6Time+" s");
	}

	/**
	 * 测试并查集性能
	 *
	 * @param unionFind
	 * @param n
	 * @return double
	 * @author whx
	 * @version 2018/9/1
	 */
	public static double testUnionFind(UnionFind unionFind, int n){
		int size = unionFind.getSize();
		Random random = new Random();

		long startTime = System.nanoTime();

		for (int i = 0; i < n; i++) {
			int a = random.nextInt(size);
			int b = random.nextInt(size);
			unionFind.unionElements(a,b);
		}

		for (int i = 0; i < n; i++) {
			int a = random.nextInt(size);
			int b = random.nextInt(size);
			unionFind.isConnected(a,b);
		}

		long endTime = System.nanoTime();
		return (endTime - startTime) / 1e9;
	}
}
u013250861
关注
专栏目录
数据结构 | 第十一章：二叉树和其他树 | 【前序遍历】【中序遍历】【后序遍历】【层次遍历】 | 并查集
知识库搭建ing
01-09 670
《数据结构、算法与应用（C++语言描述）》第十一章：二叉树和其他树，结合课程重点的自留笔记。
【数据结构与算法基础】并查集原理、封装实现及例题解析（C和java）
wayne_lee_lwc的博客
11-13 533
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
树形数据结构（一） 并查集（Union-find）
z2656453168的博客
10-05 311
树形数据结构（一） 并查集（Union-find）概念结构并查集的初始化find()find()find()merge()merge()merge()优化路径压缩按秩合并 概念 并查集是一种树形数据结构，主要用于解决元素的分组问题，管理一系列不相交的集合，它支持两种操作： 合并：将两个不相交的集合合并为一个集合 查询：查询元素所在集合 结构 并查集的一个节点只需要存储它的父节点，即可通过父节点递归寻找到根节点，因此并查集只需要一个一维数组即可实现 并查集的初始化 并查集使用一个元素代表整个集合，如图，对
数据结构之并查集 Union Find 剖析
chen
03-15 520
数据结构之并查集 Union Find 剖析 文章目录数据结构之并查集 Union Find 剖析概述原理时间复杂度分析实现实现Quick Find并查集实现Quick Union并查集考虑size优化并查集基于rank优化并查集路径压缩优化并查集Leetcode 547. Friend Circles相关链接公众号参考 概述 并查集（英文：Disjoint-set data structure，直译为不交集数据结构）： 是一种数据结构， 用于处理一些不交集（Disjoint sets，一系列没有重复元素
【数据结构-树】1.树与森林（树的遍历、树的存储方法、并查集的实现）
为了远大的理想，冲锋！
01-20 1586
树的定义 树是一种数据结构，它是由 n(n>=1)n(n>=1)n(n>=1) 个有限结点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点 每个结点有零个或多个子结点； 没有父结点的结点称为根结点； 每一个非根结点有且只有一个父结点； 除了根结点外，每个子结点可以分为多个不相交的子树； 树适合于表示具有层次的数据。树中的某个结点（除了根结点）最多只和上一层的一个结点（及其父结点）有直接关系，根结点没有直接上层结
数据结构《14》----并查集 Union-Find
L.J.SHOU的专栏
02-26 2550
描述：     并查集是一种描述解决等价关系。能够方便地描述不相交的多个集合。     支持如下操作    1. 建立包含元素 x 的集合  MakeSet(x)                               2. 查找给定元素所在的集合 Find(x)， 返回所在集合的代表                               3. 将两个不相交的集合合并 Union
树和并查集基本操作（C语言）
04-07
在计算机科学中，数据结构是组织和管理大量数据的有效方式，而树和并查集是两种常用的数据结构。本文将详细讲解这两种数据结构的基本概念、操作以及C语言中的实现。 首先，我们来看“树”这一数据结构。树是一种非...
数据结构（用数组模拟链表，队列，栈，KMP，Trie树，并查集的基本模板）
caijixiangzi的博客
07-10 387
南昌理工acm暑假集训 本周仅学习了部分数据结构模板和做了写模板题 下周将剩余数据结构（两节）学完并刷题巩固。 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。 以数组模拟链表 优点： 好理解、不需要直接处理指针更不容易 RE 1.单链表
LeetCode Union-Find(并查集) 专题（一）
Guo15331092的博客
12-03 7331
LeetCode Union-Find(并查集) 专题（一）前言： 写这个专题本意还是和之前一样 ，一篇一篇写博客写的腻了。来个专题换换感觉。（手动滑稽好吧其实是觉得并查集是一个比较实用的数据结构。 之前听老师在课上提到过一次， 在那之前很早就听过这个， 也是一只因为懒没去真正了解。 趁着这两天空闲时间把它熟悉了一下， 发现并不难。（难度和二分查找的变式差不多吧）下面进入正题。 LeetCode
21_动态规划与数据结构结合
刘炫320的博客
09-11 475
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
BamBoo_Bean的博客
09-10 659
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
数据结构——线性表（顺序存储结构和单链表结构）
weixin_74209413的博客
09-08 894
线性表（List）：由零个或多个数据元素组成的有限序列。（1）它是一个序列，也就是元素之间有个先来后到的；（2）若元素有多个，则第一个元素无前驱，最后一个无后继；（3）线性表是有限的；原子类型：不可以再分解的基本类型，例如整形、浮点型、字符型等结构类型：由若干个类型组合而成，是可以再分解的，例如整形数组是由若干个整形数据组成的。抽象数据类型抽象数据类型是指一个数学模型及定义在该模型上的一组操作；抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。
数据结构 1
2401_83575662的博客
09-14 341
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
【JavaScript】数据结构之字典 & 哈希表
最新发布
票票的博客
09-14 410
数据结构之字典和哈希表
数据结构 - 链表
kaneki_lh的博客
09-11 415
listnode;/* 双向链表结构体 */}dlinklist;
数据结构————栈的讲解(超详细！！！)
braveact的博客
09-11 900
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出（先进后出）原则。特性与栈的结构有关。
数据结构(7.3_1)——二叉排序树
m0_65240792的博客
09-14 375
又称左子树结点值<根结点值<右子树结点值进行中序遍历，可以得到一个递增的有序序列二叉排序树可用于元素的有序组织，搜索。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值