并查集笔记

最新推荐文章于 2024-08-13 14:56:59 发布
最新推荐文章于 2024-08-13 14:56:59 发布
阅读量156 收藏
点赞数
文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53680228/article/details/122358850
版权
并查集是一种数据结构，用于高效处理网络中节点的连接状态。通过合并（union）和判断连接（isConnected）两个基本操作，实现元素集合的动态维护。常见的并查集实现包括数组表示和树形结构，其中树形结构通过路径压缩和基于rank的优化提升效率。在大规模数据下，路径压缩和优化后的并查集能显著减少查找和合并的时间复杂度。
摘要由CSDN通过智能技术生成

并查集Union Find

一、并查集解决什么问题？

可以非常高效的解决网络中节点的连接问题

二、操作

1>合并 union(p,q)

2>是否连接 isConnected(p,q)

注意：在使用并查集时，我们并不关心元素内容，因此可以使用数组保存元素，p和q分别对

应元素所在数组的索引

接口：

public interface UF {
    // 获取元素的个数
    int getSize();

    // 合并操作
    void union(int p, int q);

    // 判断是否连接
    boolean isConnection(int p, int q); // p和q代表的是元素所在数组的索引
}

三、并查集的基本数据表示

在这里插入图片描述

索引为0和3的元素是否连接？因为它们同属于一个集合，所以是连接的

索引为0和5的元素是否连接？因为它们不属于同一个集合，所以是不连接的

四、代码表示

  int[] ids; // 元素所属的集合
  public UnionFind01(int length) {
        ids = new int[length];
        for (int i = 0; i < ids.length; i++) {
            ids[i] = i;
        }
    }

其中：

id数组，代表元素所属的集合

默认情况下，每个元素都是独立的，相当于每个元素所属不同的集合，没有元素相连接。

在这里插入图片描述

五、合并操作

在这里插入图片描述

合并元素索引为1和4的集合 union(1,4)

在这里插入图片描述

所以复杂度为O(n)

六、真正的并查集实现

将每个元素看作是一个结点，结点之间相连接，形成树的结构
在这里插入图片描述

结点3与结点2相连接

将结点1与结点3相合并，只要将结点1指向结点3所在那棵树的根结点。

在这里插入图片描述

public class UnionFind01 implements UF {

    int[] ids; // 元素所属的集合

    public UnionFind01(int length) {
        ids = new int[length];
        for (int i = 0; i < ids.length; i++) {
            ids[i] = i;
        }
    }

    // 辅助的方法 (根据元素所在数组的索引找所在集合的编号)
    int find(int index) {
        return ids[index];
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            for (int i = 0; i < ids.length; i++) {
                if (find(i) == qBoxNum) {
                    ids[i] = pBoxNum;
                }
            }
        }
    }

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

七、数据表示

在这里插入图片描述

在这里插入图片描述

依次进行union(6,5).union(9,4),union(2,1),union(5,0),union(7,2),union(6,2),最终得到

在这里插入图片描述

public class UnionFind02 implements  UF {

    int[] parents;

    public UnionFind02(int length){
        parents = new int[length];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }

    private int find(int index){
        while (index != parents[index]) {
            index = parents[index];
        }
        return index;
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            parents[pBoxNum] = qBoxNum;
        }
    }

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

判断索引为6和4的元素是否连接？

索引为6的元素所在树的根节点为1，索引为4的元素所在树的根节点为8，所以没有连接。

八、测试并查集

public class DemoTest {

    public static void test(UF uf, int count) {
        long startTime = System.nanoTime();
        int size = uf.getSize();
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
            int p = random.nextInt(size);
            int q = random.nextInt(size);
            uf.union(p, q);
        }
        for (int i = 0; i < count; i++) {
            int p = random.nextInt(size);
            int q = random.nextInt(size);
            uf.isConnection(p, q);
        }
        long endTime = System.nanoTime();
        System.out.println("Times:" + (endTime - startTime) / 1000000000.0);
    }

    public static void main(String[] args) {
        int size = 10000000;
        int count = 10000000;
        UF uf = new UnionFind01(size);
        test(uf,count);
        UF uf2 = new UnionFind02(size);
        test(uf2,count);
/*        UF uf3 = new UnionFind03(size);
        test(uf3,count);
        UF uf4 = new UnionFind04(size);
        test(uf4,count);
        UF uf5 = new UnionFind05(size);
        test(uf5,count);
        UF uf6 = new UnionFind06(size);
        test(uf6,count);*/
    }
}

结果会发现：当数据size = 100000,count = 100000时，使用树结构形式存储连接关系的并查集

比使用数组的形式耗时要长。归其原因：不管是查询操作还是合并操作，使用树结构形式的

并查集的复杂度为O(h),在极端的情况下，这棵树的深度会比较大。

在这里插入图片描述

九、基于size的优化

在这里插入图片描述

/**
 * 基于Size优化
 */
public class UnionFind03 implements  UF {

    int[] parents;
    int[] size; // 来保存每棵树结点的个数

    public UnionFind03(int length){
        parents = new int[length];
        size = new int[length];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
            size[i]= 1;
        }
    }

    private int find(int index){
        while (index != parents[index]) {
            index = parents[index];
        }
        return index;
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            if (size[pBoxNum] > size[qBoxNum]) {
                parents[qBoxNum] = pBoxNum;
                size[pBoxNum] += size[qBoxNum];
            } else {
                parents[pBoxNum] = qBoxNum;
                size[qBoxNum] += size[pBoxNum];
            }
        }
    }

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

解决的思路：将元素个数少的树合并到元素个数多的树上。需要开辟空间，存放每棵树的元

素个数。 【int[] size】

十、基于rank优化

基于size优化的缺点：
在这里插入图片描述
在这里插入图片描述

/**
 * 基于高度进行优化
 */
public class UnionFind04 implements UF {

    int[] parents;
    int[] rank; // 基于高度进行优化 ---由低到高

    public UnionFind04(int length) {
        parents = new int[length];
        rank = new int[length];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
            rank[i] = 1;
        }
    }

    private int find(int index) {
        while (index != parents[index]) {
            index = parents[index];
        }
        return index;
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            if (rank[pBoxNum] > rank[qBoxNum]) {
                parents[qBoxNum] = pBoxNum;
            } else if (rank[qBoxNum] > rank[pBoxNum]) {
                parents[pBoxNum] = qBoxNum;
            } else {
                parents[pBoxNum] = qBoxNum;
                rank[qBoxNum] += 1;
            }
        }
    }

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

十一：路径压缩

在这里插入图片描述
在这里插入图片描述

方法：parent[p]= parent[parent[p]] 路径压缩发生的时机：find操作

在查询时执行，执行

在这里插入图片描述

/**
 * 进行路径压缩
 */
public class UnionFind05 implements UF {
    int[] parents;

    public UnionFind05(int length) {
        parents = new int[length];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }


    private int find(int index) {
        while (index != parents[index]) {
            // 路径压缩
            parents[index] = parents[parents[index]];
            index = parents[index];
        }
        return index;
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            parents[qBoxNum] = pBoxNum;
        }
    }

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


/**
 * 进行路径压缩
 */
public class UnionFind06 implements UF {
    int[] parents;

    public UnionFind06(int length) {
        parents = new int[length];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }


    private int find(int index) {
        if (index != parents[index]) {
            parents[index] = find(parents[index]);
        }
        return parents[index];
    }

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

    @Override
    public void union(int p, int q) {
        int pBoxNum = find(p);
        int qBoxNum = find(q);
        if (pBoxNum != qBoxNum) {
            parents[qBoxNum] = pBoxNum;
        }
    }

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

public int getSize() {
    return parents.length;
}

@Override
public void union(int p, int q) {
    int pBoxNum = find(p);
    int qBoxNum = find(q);
    if (pBoxNum != qBoxNum) {
        parents[qBoxNum] = pBoxNum;
    }
}

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

}

¥奔跑的蜗牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
并查集 (Union-Find Sets)
vsooda的专栏
02-26 1069
如果：给出各个元素之间的联系，要求将这些元素分成几个集合，每个集合中的元素直接或间接有联系。在这类问题中主要涉及的是对集合的合并和查找，因此将这种集合称为并查集。  链表被普通用来计算并查集.表中的每个元素设两个指针：一个指向同一集合中的下一个元素；另一个指向表首元素。 链结构的并查集 采用链式存储结构，在进行集合查找时的算法复杂度仅为O（1）；但合并集合时的算法复杂
并查集Python版
小小博客
10-12 1957
整理之前python版的并查集资料
并查集学习笔记
ex_voda的博客
08-13 935
整理了并查集的一些知识点和应用方法，如果有的话会更新补充
并查集算法
ZergWang's Blog
03-15 6905
引入 并查集（disjoint-set data structure，或union–find data structure）是一种树型数据结构，用于处理互相不相交的集合中元素的查询与合并。 举个例子，现在有n个相互独立的点和m条线，首先读入n和m，接下来m行每行读入x,y，代表点x与点y相连。这些点通过线相互连接，可能构成一张或多张图，最后问共构成几张互不连通的无向图或者任意两节点是否连通。 样例读入： 5 3 1 3 3 2 4 5 由样例读入可得，1、2、3构
并查集（标准并查集、带权并查集、扩展域并查集）
xmf_learn_c的博客
07-15 1908
并查集是一种数据结构，用来管理集合之间的关系，可以用来进行判断是否属于同一集合或将不同的集合合并等操作。我们用个生活中的例子来说明一下原本小明家这个集合只有小明，小红家只有小红，那么他们结婚后（合并）就属于一个家庭（一个集合），像这样，通过并查集我们能够合并不同的集合，然后还能快速地查找他们是不是同一个集合。
【考研】数据结构：并查集（2022 新增考点）
qq_34438969的博客
10-21 2718
一、前言 并查集，是 2022 新增考点，下面关于并查集的内容是根据王道讲解所总结的笔记（选择题和大题都有可能考）。 备注：并查集，在2022王道《数据结构》里有讲解，在第164页。 二、并查集 1、并查集：顺序存储，每一个集合组织成一棵树，采用 “ 双亲表示法 ”。 2、上代码 （1）基本内容 // 并查集的结构定义 #define SIZE 100 int UFset[SIZE]; // 集合元素数组（双亲指针数组） // 初始化（s[] 即为并查集） void Ini.
408数据结构学习笔记——树与二叉树的应用——哈夫曼树和哈夫曼编码、并查集
JiangNan_1002的博客
04-07 1877
1.哈夫曼树和哈夫曼编码 2.并查集
并查集详解
晴空๓
02-15 3165
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。并查集的思想是用一个数组表示了整片森林（parent），树的根节点唯一标识了一个集合，我们只要找到了某个元素的的树根，就能确定它在哪个集合里。
算法笔记【2】 并查集
热门推荐
Zack_tzh的博客
01-21 1万+
算法笔记【1】 并查集 并查集简介 并查集被很多OIer认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作： 合并（Union）：把两个不相交的集合合并为一个集合。 查询（Find）：查询两个元素是否在同一个集合中。 当然，这样的定义未免太过学术化，看完后恐怕不太能理解它具体有什么用。所以我们先来看看并查集最直接的一个应用场景：亲戚问题。 题目背景 若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意
算法：并查集
OceanStar的博客
06-18 2151
简单来说，动态连通性可以抽象为一幅图连线。比如下面图中，一共有10个节点，它们互不相连，分别用0 90~90 9标记 并查集算法需要实现如下操作： 这里说的[连通]是一种等价关系，也就是说具有如下三个性质：如上图： 判断这种「等价关系」 ⾮常实⽤， ⽐如说编译器判断同⼀个变量的不同引⽤， ⽐如社交⽹络中的朋友圈计算等等。而Union-Find 算法的关键就在于 union 和 connected 函数的效率。 那么⽤什么模型来表⽰这幅图的连通状态呢？ ⽤什么数据结构来实现代码呢？一般使⽤森林（若⼲棵树）
Python LoRA 模型查询笔记.md
08-16
LoRA（Learnonce, Recall Anytime）是一种模型查询技术，其核心目标在于通过训练一个全局模型，并将其转换为一种高效的查询结构，以此实现在新数据上进行快速预测。这一技术在机器学习领域尤其有价值，因为传统模型...
ORACLE学习笔记-查询篇
09-10
在Oracle中，查询是数据操作的核心，本篇笔记将重点介绍Oracle查询的基本语法和一些高级特性。 首先，我们从最基础的查询开始。在Oracle中，使用`SELECT`语句来获取数据。例如，`SELECT * FROM STU` 将返回表`STU`...
SQL学习全笔记
12-22
本笔记将全面介绍SQL的基础概念、高级查询技巧以及常用的函数，旨在帮助初学者快速入门并深入理解SQL。 首先，SQL的基础部分包括数据库的创建、删除和修改。在Oracle数据库系统中，你可以使用`CREATE DATABASE`语句...
thinkphp学习笔记之多表查询
10-25
多表查询允许我们从两个或多个相关的数据表中提取并组合数据，以满足复杂的数据处理需求。以下将详细介绍ThinkPHP中进行多表查询的几种方法，并通过一个实际的案例来说明。 首先，我们需要了解在ThinkPHP中如何进行...
mybatis笔记mybatis笔记mybatis笔记
11-06
MyBatis的主要特点在于它允许开发者自定义SQL查询，支持存储过程，以及高级的映射功能，从而避免了JDBC中的大量手动参数设置和结果集处理。这种设计降低了Java代码与SQL的耦合度，使得代码更易于维护。 MyBatis ...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 503
开始，
排序算法之桶排序
rd_w_csdn的博客
08-12 826
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
备战秋招60天算法挑战，Day17
最新发布
溜达虎的博客
08-13 369
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 680
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
优化并查集：降低合并操作复杂度
"这篇资料主要介绍了并查集这一数据结构，并通过一个具体的问题——PKU1703，探讨了并查集在解决实际问题中的应用。并查集主要用于处理不相交集合的问题，支持合并集合和查询元素所属集合的操作。在代码实现中，提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值