并查集

最新推荐文章于 2024-09-18 13:33:45 发布
最新推荐文章于 2024-09-18 13:33:45 发布
阅读量4.2k 收藏 16
点赞数 9
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43609475/article/details/112314898
版权

参考
https://www.cnblogs.com/asdfknjhu/p/12515480.html
https://www.bilibili.com/video/BV13t411v7Fs?p=3
https://leetcode-cn.com/problems/number-of-provinces/solution/python-duo-tu-xiang-jie-bing-cha-ji-by-m-vjdr/

一、基本概念

并查集是一种数据结构
并查集这三个字，一个字代表一个意思。
并（Union），代表合并
查（Find），代表查找
集（Set），代表这是一个以字典为基础的数据结构，它的基本功能是合并集合中的元素，查找集合中的元素
并查集的典型应用是有关连通分量的问题
并查集解决单个问题（添加，合并，查找）的时间复杂度都是 O(1) O(1) O(1)
因此，并查集可以应用到在线算法中

二、并查集的引入

假设有一个图如下图所示：
图片

问题：我们要判断该图有没有环？
如下图所示红线连接的就是一个环
在这里插入图片描述

第一步：将图中6个点平铺写开
在这里插入图片描述第二步：任意从图中的一个边开始，把所有的边都给遍历一遍，首先选择01之间的边，选择边后 我们把这条边所连接的两个顶点放到一个集合中，如下图示：
在这里插入图片描述选择12之间的边，选择边后 我们把这条边所连接的两个顶点放到一个集合中，1已经在集合中了，只需要把2放进去就可以了。集合的意义是该集合中的元素可以在图中相互走通的（即任意两个元素是直接或者间接相连的）如下图示：

在这里插入图片描述
选择34之间的边，选择边后 我们把这条边所连接的两个顶点放到一个集合中，3和4与上一个集合中的元素目前没有连接所以单独放在一个集合中。如下图示：
在这里插入图片描述
选择13之间的边，选择边后 我们把这条边所连接的两个顶点放到一个集合中，13分别在一个集合中，要让他们在一个集合中就要将13所在的集合合并。如下图示：
在这里插入图片描述
到目前为止我们使用过得边有（0，1）（1，2）（3，4）（1，3），由于我们选边的时候不会重复且边（0,1）和（1,0）是同一条边。如果接下来选边的时候（选边不重复），该边的两个端点出现在同一个集合中，则该集合元素可以构成一个环，即该图是有环的。如选择边24,24在集合中，所以可以构成环，该图有环。如图示：在这里插入图片描述
用代码实现的时候用树的结构来存储上面说的集合。在集合合并的时候如果一个边的两个结点所在的树（存储集合的）的根节点指向另一个树的根节点：

在这里插入图片描述在这里插入图片描述在这里插入图片描述
接下来找到边24 2的根和4的根相同都是4，这说明顶点2和4本身就在集合中（树上）。即有环。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define VERTICES 6
int find_root(int x, int parent[])  // 找到根节点
{
    int x_root = x;
    while (parent[x_root] != -1)
    {
        x_root = parent[x_root];
    }
    return x_root;
}
int union_vertices(int x, int y, int parent[])  // 让两个集合合并
{
    int x_root = find_root(x, parent);
    int y_root = find_root(y, parent);
    if (x_root == y_root)
        return 0;
    else
    {
        parent[x_root] = y_root;
        return 1;
    }
}
int main(void)
{
    int parent[VERTICES] = { 0 };
    memset(parent, -1, sizeof(parent));   // 初始化
    int edges[6][2] = { {0,1},{1,2},{1,3},{2,4},{3,4},{2,5} }; // 边集

    for (int i = 0; i < 6; i++)
    {
        int x = edges[i][0];
        int y = edges[i][1];
        if (union_vertices(x, y, parent) == 0)
        {
            printf("Cycle detected!\n");
            system("pause");
            exit(0);
        }
    }
    printf("No cycle found.\n");

    system("pause");
    return 0;
}

三、根据Rank的合并（压缩路径）

为了避免树的构建出现链条形状，影响根的查询，所以在合并的时候让矮树的根节点指向高树的根节点。
在这里插入图片描述在这里插入图片描述在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define VERTICES 6
int find_root(int x, int parent[])  // 找到根节点
{
    int x_root = x;
    while (parent[x_root] != -1)
    {
        x_root = parent[x_root];
    }
    return x_root;
}
int union_vertices(int x, int y, int parent[],int rank[])  // 让两个集合合并
{
    int x_root = find_root(x, parent);
    int y_root = find_root(y, parent);
    if (x_root == y_root)
        return 0;
    else
    {
        if (rank[x_root] > rank[y_root])  // 让 少的指向多 的
        {
            parent[y_root] = x_root;
        }
        else if (rank[x_root] < rank[y_root])
            parent[x_root] = y_root;
        else
        {
            parent[x_root] = y_root;   // 这个随便可以
            rank[y_root]++;
        }
        return 1;
    }
}
int main(void)
{
    int parent[VERTICES] = { 0 };
    int rank[VERTICES] = { 0 };
    memset(rank, 0, sizeof(rank));
    memset(parent, -1, sizeof(parent));
    int edges[6][2] = { {0,1},{1,2},{1,3},{2,4},{3,4},{2,5} };

    for (int i = 0; i < 6; i++)
    {
        int x = edges[i][0];
        int y = edges[i][1];
        if (union_vertices(x, y, parent,rank) == 0)
        {
            printf("Cycle detected!\n");
            system("pause");
            exit(0);
        }
    }
    printf("No cycle found.\n");

    system("pause");
    return 0;
}

python并查集模板分析

一、并查集的实现

1、集合树用字典存储的定义

并查集跟树有些类似，只不过她跟树是相反的。在树这个数据结构里面，每个节点会记录它的子节点。在并查集里，每个节点会记录它的父节点。
并查集使用的是字典来存储树，字典的键是子节点，值是父节点。并且把一个并查集的所有操作和存储结构封装到一个类中：

class UnionFind:

    def __init__(self):
        """
        记录每个节点的父节点
        """
        self.father = {}
       # self.value = {}  如果边有权重 # key 本节点名称 ，value 为本节点 到 根点的权值

在这里插入图片描述可以看到，如果节点是相互连通的（从一个节点可以到达另一个节点），那么他们在同一棵树里，或者说在同一个集合里，或者说他们的祖先是相同的。

2、初始化

当把一个新节点添加到并查集中，它的父节点应该为空

 def add(self,x):
        """
        添加新节点
        """
        if x not in self.father:
            self.father[x] = None

在这里插入图片描述

3、合并两个节点

如果发现两个节点是连通的（两个节点被一个边连接起来），那么就要把他们合并。然后如果他们的根是相同的（同属一棵树），则任选一个节点作为另一个结点的父节点。这里究竟把谁当做父节点一般是没有区别的。如果他们的根是不同的，则让一个树的根节点作为另一个数的根节点的父节点。

def merge(self,x,y,val):
        """
        合并两个节点
        """
        root_x,root_y = self.find(x),self.find(y) # 查找结点x和y的根节点  
        if root_x != root_y:						# 根节点不相同 则合并
            self.father[root_x] = root_y

在这里插入图片描述

4、查找一个节点的根节点

查找一个节点的根节点方法是：如果节点的父节点不为空，那就不断迭代。

def find(self,x):
        """
        查找根节点
        """
        root = x

        while self.father[root] != None:
            root = self.father[root]
        return root

在这里插入图片描述

5、路径压缩

这里有一个优化的点：如果我们树很深，比如说退化成链表，那么每次查询的效率都会非常低。所以我们要做一下路径压缩。也就是把树的深度固定为二。

这么做可行的原因是，并查集只是记录了节点之间的连通关系，而节点相互连通只需要有一个相同的根节点（祖先）就可以了。

路径压缩可以用递归，也可以迭代。这里用迭代的方法。

    def find(self,x):
        """
        查找根节点
        路径压缩
        """
        root = x

        while self.father[root] != None:
            root = self.father[root]

        # 路径压缩
        while x != root:
            original_father = self.father[x]
            self.father[x] = root
            x = original_father
         
        return root

路径压缩的时间复杂度为O(log⁡∗n)O(\log^*n)O(log∗n)
log⁡∗n\log^*nlog∗n 表示 n 取多少次log⁡2n\log_2nlog2​n并向下取整以后 变成 1
可以认为O(log⁡∗n)=O(1)O(\log^*n) = O(1)O(log∗n)=O(1),因为log⁡∗265536=5\log*2{65536} = 5log∗265536=5，而2655362^{65536}265536是一个天文数字。这个时间复杂度当成结论记下就可以。
在这里插入图片描述在这里插入图片描述

6、两节点是否连通

我们判断两个节点是否处于同一个连通分量的时候，就需要判断它们的根节点（祖先）是否相同

def is_connected(self,x,y):
        """
        判断两节点是否相连
        """
        return self.find(x) == self.find(y)

完整模板

class UnionFind:
    def __init__(self):
        """
        记录每个节点的父节点
        """
        self.father = {}
    
    def find(self,x):
        """
        查找根节点
        路径压缩
        每一次查找节点x的根节点的时候都对该节点进行路径压缩
        """
        root = x

        while self.father[root] != None:
            root = self.father[root]

        # 路径压缩
        while x != root:
            original_father = self.father[x]
            self.father[x] = root
            x = original_father
         
        return root
    
    def merge(self,x,y,val):
        """
        合并两个节点
        """
        root_x,root_y = self.find(x),self.find(y)
        
        if root_x != root_y:
            self.father[root_x] = root_y

    def is_connected(self,x,y):
        """
        判断两节点是否相连
        """
        return self.find(x) == self.find(y)
    
    def add(self,x):
        """
        添加新节点
        """
        if x not in self.father:
            self.father[x] = None
并查集的实现
金州饿霸吃不饱的博客
12-25 699
并查集是什么 并查集是一种用来管理元素分组情况的数据结构。并查集可以高效地进行如下操作。不过需要注意并查集虽然可以进行合并操作，但是却无法进行分割操作 查询元素a和元素b是否属于同一组 合并元素a和元素b所在的组 并查集的结构 并查集也是使用树形结构实现的，不过不是二叉树。 每个元素对应一个节点，每个组对应一棵树。在并查集中，哪个节点是哪个节点的父亲以及树的形状等信息无需多家关注，整体组成一个树形结构才是重要的。 （1）初始化 我们准备n个节点来表示n个元素。最开始..
Java实现并查集
08-18
Java实现并查集 Java实现并查集是指使用Java语言实现的并查集数据结构。并查集是一种树形结构，可以高效地解决元素之间的连接和分离问题。以下是Java实现并查集的详细知识点： 一、并查集的定义 并查集是一种树形...
【高级数据结构】并查集
最新发布
Antonio915的博客
09-18 2405
前面讲解了并查集的基本应用—一处理集合问题。在这些基本应用中,点之间只有简单的归属关系,而没有权值。如果在点之间加上权值,并查集的应用会更广泛。如果读者联想到树这种数据结构,会发现并查集实际上是在维护若干棵树。并查集的合并和查询优化,实际上是在改变树的形状,把原来“细长”的,操作低效的大量“小树”,变为“粗短”的、操作高效的少量“大树”。如果在原来的“小树”上,点之间有权值,那么经过并查集的优化变成“大树”后,这些权值的操作也变得高效了。定义一个权值数组dd[]d,把节点iii。
zz POJ 并查集 题目汇总
weixin_33946605的博客
04-22 204
POJ 并查集 题目汇总: http://hi.baidu.com/czyuan_acm/blog/item/531c07afdc7d6fc57cd92ab1.html 继续数据结构的复习，本次的专题是：并查集。 并查集，顾名思义，干的就是“并”和“查”两件事。很多与集合相关的操作都可以用并查集高效的解决。 两个操作代码： int...
并查集讲义并查集知识学习讲解
07-14
并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复...
C++并查集亲戚(Relations)算法实例
09-03
并查集（Disjoint Set）是一种数据结构，用于处理一些不相交集合的合并与查询问题。在C++中，实现并查集可以高效地解决亲戚关系查询的问题，特别是当关系网络庞大时。本实例主要关注如何使用并查集算法处理亲戚关系...
Java使用HashMap实现并查集
08-25
Java使用HashMap实现并查集 Java使用HashMap实现并查集是指使用Java语言中的HashMap数据结构来实现并查集。并查集是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以...
【坐在马桶上看算法】啊哈算法13：零基础彻底弄懂"并查集"
weixin_33904756的博客
01-31 1601
咱们从一个故事说起——解密犯罪团伙。快过年了，犯罪分子们也开始为年终奖“奋斗”了，小哼的家乡出现了多次抢劫事件。由于强盗人数过于庞大，作案频繁，警方想查清楚到底有几个犯罪团伙实在是太不容易了，不过警察叔叔还是搜集到了一些线索，需要咱们帮忙分析一下。现在有11个强盗。1号强盗与2号强盗是同伙。3号强盗与4号强盗是同伙。5号强盗与2号强盗是同伙。4号强盗与6号强盗是同伙。2号强盗...
3367 【模板】并查集
weixin_30908649的博客
11-02 354
题目描述 如题，现在有一个并查集，你需要完成合并和查询操作。 输入输出格式 输入格式： 第一行包含两个整数N、M，表示共有N个元素和M个操作。 接下来M行，每行包含三个整数Zi、Xi、Yi 当Zi=1时，将Xi与Yi所在的集合合并 当Zi=2时，输出Xi与Yi是否在同一集合内，是的话输出Y；否则话输出N 输出格式： 如上，对于每一个Zi=2的操作，都有一行输出，每行包含一个...
并查集的使用及其实现
热门推荐
The_best_man的博客
03-16 3万+
并查集概述性质并查集算法（union_find sets）不支持分割一个集合,求连通子图、求最小生成树用法并查集是由一个数组pre[]，和两个函数构成的，一个函数为find()函数，用于寻找前导点的，第二个函数是join()用于合并路线的int find(int x) { int r=x; while(pre[r]!=r) r=pre[r];//找到他的前导结点 in
并查集详解与应用
"并查集入门" 并查集是一种用于处理集合动态合并与查询问题的数据结构，常用于解决一些具有连接关系的问题，如图的连通性判断、团伙问题等。在ACM（国际大学生程序设计竞赛）中，由于其高效的操作特性，被广泛应用...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值