并查集实现等价类

最新推荐文章于 2024-09-11 21:53:26 发布
最新推荐文章于 2024-09-11 21:53:26 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 数据结构与算法 
等价关系:集合或类(以集合为例)上的等价关系R指一个具有自反, 对称, 传递性的二元关系。
等价类: 在一个定义了等价关系的集合中可以按该等价关系分成等价类(即两个元素只要有xRy, 则它们属于同一等价类), 即集合的一些子集组成的集,。容易证明这些等价类两两不交且其并等于原集合.
 假设集合S有n个元素,m个形如(x,y) (x,y 属于 S)的等价偶对确定了等价关系R,如何求S的划分，即该如何求S的等价类?? 
 1）利用链表结构实现
  2）利用并查集实现(我么这里将讨论的)

并查集:并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。

并查集方式求等价类的方法如下:

    （1）令集合S中每个元素个子形成一个只包含单个成员的子集,记为S0,S1,...Sn-1.

      (2)  重复读入m个偶对,对每个读入的偶对(x,y),判定x和y所属子集。假设x属于Si,y属于Sj,如果Si != Sj,侧将Si 并于 Sj并将Si置空(或将Sj并于Si,                      并将Sj置空)。则当m个偶对都被处理过后，S0,S1，...，Sn-1中所有非空子集即为S的R等价类.


由此可见并查集方式求子集关键是1）查找一个元素所属的集合.2)求二个子集的合集3）求非空集合

并查集的定义

[cpp]  view plain copy
  1. const int Max_TreeNode=100;//树的节点的最大值  
  2. //利用双亲表示法表示树  
  3.   
  4. template <typename T>   
  5. class UFSET  
  6. {  
  7. public:  
  8.     //树的节点定义  
  9.    typedef struct TreeNode  
  10.    {  
  11.      T data;//树的节点的值  
  12.      int parent;//节点的双亲所在的位置(如果该节点为根节点侧该值为以该节点为根的树的节点个数的负值)  
  13.    } TreeNode, *PTreeNode ;  
  14.       
  15.     TreeNode nodes[Max_TreeNode];  
  16.     int n;//节点个数(集合元素的个数)  
  17.       
  18.     UFSET(T * datas,int size):n(size)//datas为集合中所有元素值的集合,size为集合元素的个数  
  19.     {  
  20.         for(int i=0;i<size;i++)  
  21.         {  
  22.             nodes[i].data=datas[i];  
  23.             //最开始令每个元素各自形成只包含该元素的子集  
  24.             nodes[i].parent=-1;  
  25.         }  
  26.     }  
  27. };  

      查找元素所属的集合
[cpp]  view plain copy
  1. //查找元素e所属的集合（用根节点所在位置表示集合）  
  2. template <typename T>  
  3. int find(UFSET<T> & t,T e)  
  4. {  
  5.    //先找到值为e的节点  
  6.    for(int i=0;i<t.n;++i)  
  7.    {  
  8.     if(t.nodes[i].data==e)  
  9.     {    
  10.        int j;  
  11.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
  12.        return j;  
  13.     }  
  14.    }  
  15.    return -1;//表示值为e的节点不存在  
  16. }  

   当所查元素i不在树的第二层时，在算法中增加一个“压缩路劲的功能”，将所有从根到元素路径上的元素都变成树根的孩子。

  查找元素所属的集合的改进型

[cpp]  view plain copy
  1. //find函数的一种改进型  
  2. template <typename T>  
  3. int mix_find(UFSET<T> & t,T e)  
  4. {  
  5.    //先找到值为e的节点  
  6.    for(int i=0;i<t.n;++i)  
  7.    {  
  8.     if(t.nodes[i].data==e)  
  9.     {    
  10.        int j;  
  11.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
  12.        //将所有从节点t.nodes[i]到根t.nodes[j]的路径上的节点都变成根t.nodes[j]的孩子  
  13.        while(i!=j)  
  14.        {  
  15.           int temp=t.nodes[i].parent;  
  16.           t.nodes[i].parent=j;  
  17.           i=temp;  
  18.        }  
  19.        return j;  
  20.     }  
  21.    }  
  22.    return -1;//表示值为e的节点不存在  
  23. }  

合并子集

[cpp]  view plain copy
  1. //合并子集  
  2. //将节点少的子集合并到节点多的子集上  
  3. template <typename T>  
  4. void merger(UFSET<T> & t,int i,int j)  
  5. {  
  6.    // t.nodes[i]和 t.nodes[j] 分别表示集合的两个互不相交的子集Si和Sj的根节点  
  7.    if(i<0 || i>t.n || j<0 || j>t.n)  
  8.        return ;  
  9.    if(t.nodes[i].parent>t.nodes[j].parent)//t.nodes[i]的节点个数少于t.nodes[j]的节点个数  
  10.    {  
  11.       t.nodes[j].parent+=t.nodes[i].parent;  
  12.       t.nodes[i].parent=j;  
  13.    }  
  14.    else  
  15.    {  
  16.       t.nodes[i].parent+=t.nodes[j].parent;  
  17.       t.nodes[j].parent=i;  
  18.    }  
  19. }  
    计算等价类

 
 

  
  

   
   

    
    [cpp] 
    
    view plain
    
    copy
    
    

   
   

  
  

  
  
  1. //计算等价类(即最后非空子集的个数)  
  2. template <typename T>  
  3. int EquClassCount(UFSET<T> & t)  
  4. {  
  5.     int count=0;  
  6.     for(int i=0;i<t.n;i++)  
  7.         if(t.nodes[i].parent<0)  
  8.             count++;  
  9.     return count;  
  10. }  

下面求解小米公司2013笔试题:

朋友圈：假如已知有n个人和m对好友关系，如果两个人是直接或者间接有好友关系，则认为他们属于同一个朋友圈。写程序判断里面有多少朋友圈。
例如 
n = 5, m = 3  r = {(1,2), (2, 3), (4, 5)}  1 2 3 是一个朋友圈， 4 5 是一个朋友圈。
所以输出是2. 

完整代码余下所示:

[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include <iostream>  
  3.    
  4. const int Max_TreeNode=100;//树的节点的最大值  
  5. //利用双亲表示法表示树  
  6.   
  7. template <typename T>   
  8. class UFSET  
  9. {  
  10. public:  
  11.     //树的节点定义  
  12.    typedef struct TreeNode  
  13.    {  
  14.      T data;//树的节点的值  
  15.      int parent;//节点的双亲所在的位置(如果该节点为根节点侧该值为以该节点为根的树的节点个数的负值)  
  16.    } TreeNode, *PTreeNode ;  
  17.       
  18.     TreeNode nodes[Max_TreeNode];  
  19.     int n;//节点个数(集合元素的个数)  
  20.       
  21.     UFSET(T * datas,int size):n(size)//datas为集合中所有元素值的集合,size为集合元素的个数  
  22.     {  
  23.         for(int i=0;i<size;i++)  
  24.         {  
  25.             nodes[i].data=datas[i];  
  26.             //最开始令每个元素各自形成只包含该元素的子集  
  27.             nodes[i].parent=-1;  
  28.         }  
  29.     }  
  30. };  
  31.   
  32. //查找元素e所属的集合（用根节点所在位置表示集合）  
  33. template <typename T>  
  34. int find(UFSET<T> & t,T e)  
  35. {  
  36.    //先找到值为e的节点  
  37.    for(int i=0;i<t.n;++i)  
  38.    {  
  39.     if(t.nodes[i].data==e)  
  40.     {    
  41.        int j;  
  42.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
  43.        return j;  
  44.     }  
  45.    }  
  46.    return -1;//表示值为e的节点不存在  
  47. }  
  48.   
  49. //find函数的一种改进型  
  50. template <typename T>  
  51. int mix_find(UFSET<T> & t,T e)  
  52. {  
  53.    //先找到值为e的节点  
  54.    for(int i=0;i<t.n;++i)  
  55.    {  
  56.     if(t.nodes[i].data==e)  
  57.     {    
  58.        int j;  
  59.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
  60.        //将所有从节点t.nodes[i]到根t.nodes[j]的路径上的节点都变成根t.nodes[j]的孩子  
  61.        while(i!=j)  
  62.        {  
  63.           int temp=t.nodes[i].parent;  
  64.           t.nodes[i].parent=j;  
  65.           i=temp;  
  66.        }  
  67.        return j;  
  68.     }  
  69.    }  
  70.    return -1;//表示值为e的节点不存在  
  71. }  
  72.   
  73. //合并子集  
  74. //将节点少的子集合并到节点多的子集上  
  75. template <typename T>  
  76. void merger(UFSET<T> & t,int i,int j)  
  77. {  
  78.    // t.nodes[i]和 t.nodes[j] 分别表示集合的两个互不相交的子集Si和Sj的根节点  
  79.    if(i<0 || i>t.n || j<0 || j>t.n)  
  80.        return ;  
  81.    if(t.nodes[i].parent>t.nodes[j].parent)//t.nodes[i]的节点个数少于t.nodes[j]的节点个数  
  82.    {  
  83.       t.nodes[j].parent+=t.nodes[i].parent;  
  84.       t.nodes[i].parent=j;  
  85.    }  
  86.    else  
  87.    {  
  88.       t.nodes[i].parent+=t.nodes[j].parent;  
  89.       t.nodes[j].parent=i;  
  90.    }  
  91. }  
  92.   
  93. //计算等价类(即最后非空子集的个数)  
  94. template <typename T>  
  95. int EquClassCount(UFSET<T> & t)  
  96. {  
  97.     int count=0;  
  98.     for(int i=0;i<t.n;i++)  
  99.         if(t.nodes[i].parent<0)  
  100.             count++;  
  101.     return count;  
  102. }  
  103.   
  104. //将元素值为e1和e2所在集合合并  
  105. template <typename T>  
  106. void mix_merger(UFSET<T> & t,T e1,T e2)  
  107. {  
  108.     int i=mix_find(t,e1);  
  109.     int j=mix_find(t,e2);  
  110.     if(i>=0 && j>=0 && i!=j)  
  111.         merger(t,i,j);  
  112. }  
  113.   
  114. int _tmain(int argc, _TCHAR* argv[])  
  115. {  
  116.     int friends[]={1,2,3,4,5};  
  117.     UFSET<int> friend_set(friends,sizeof(friends)/sizeof(int));  
  118.     mix_merger(friend_set,1,2);  
  119.     mix_merger(friend_set,2,3);  
  120.     mix_merger(friend_set,4,5);  
  121.     std::cout<<"朋友串个数为:"<<EquClassCount(friend_set)<<std::endl;  
  122.     system("PAUSE");  
  123.     return 0;  
  124. }  

本文主要参考资料:数据结构(C语言本 严蔚敏版) P139——P143
炎枫coeus
关注
专栏目录
实现并查集数据结构的技术指南
一键难忘的博客
05-22 1004
本文介绍了并查集数据结构的基本原理、实现方法以及优化技巧，并提供了代码示例展示了其在实际问题中的应用。首先，我们了解了并查集的基本操作：合并（Union）和查找（Find），以及如何使用数组来表示并查集中的树结构。随后，我们介绍了路径压缩和按秩合并两种优化技巧，用于提高并查集的效率。通过路径压缩，我们可以减少查找操作的时间复杂度；而按秩合并则可以降低树的深度，进而减少查找和合并操作的时间复杂度。在代码示例部分，我们展示了如何实现一个简单的并查集类，并给出了一个应用示例：使用并查集解决区域填充问题。
并查集（等价类）ADT学习分析
c1776167012的博客
04-06 501
一，什么是并查集？（也叫等价类） 并查集ADT(抽象数据结构)可以表示一组无序元素，可用来解决等价问题。 二，等价类中的一些操作： 1.创建一个等价类 2.查找等价类 3.合并等价类。 三，等价类的一些应用 1.表示网络的连通性 2.图像处理 3.查找最近公共祖先 4.定义有限状态自动机的等价性 5.Kruscal最小生成树算法 6.博弈算法 四，实现方法 1.快速UNION实现（慢FIND): ...
6-8-并查集（等价类）-树和二叉树-第6章-《数据结构》课本源码-严蔚敏吴伟民版...
weixin_34072458的博客
03-04 258
课本源码部分 第6章  树和二叉树 - 并查集（等价类） ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文件  ...
等价类和并查集
yx的专栏
03-14 5694
7.2 等价类和并查集7.2.1 等价关系与等价类１、在求解实际应用问题时常会遇到等价类的问题。２、 从数学上看，等价类是一个对象(或成员)的集合，在此集合中的所有对象应满足等价关系。３、 若用符号“≡”表示集合上的等价关系，那么对于该集合中的任意对象x, y, z，下列性质成立： （１）自反性：x ≡ x (即等于自身)。 （２）对称性：若 x ≡ y, 则 y ≡
325-并查集和等价类
LINZEYU666的博客
05-29 623
并查集和等价类 上面的等价对，是因为一些共同的特征特点，成为等价关系（需要具体的环境） 必须有一个场景，才有等价关系 （聚合类算法，找最优） 例如，一个女生，有10个相亲对象，女生对这10个男生标号，1,2，3，…，10，0号男生有房有车，1号男生有房有车，所以0和1就等价，以此类推下去。第一次等价划分后，还可以继续细分，以身高体重颜值进行第二次等价划分，以此类推下去。 比如，我们有12个元素，初始化为-1，-1等负数代表是根节点。接着进行b处理，0和4等价，我们在数组的4下标位置存上0值，4的双亲
c++实现并查集
11-15
2. **并查集类**: `MFEST` 类是并查集的主要实现部分，包含初始化、合并和查找三个核心方法。 - `Initial`: 初始化单个节点的方法，设置其初始的`count`为1，`father`为0（表示自己是根节点）。 - `Union`: 合并两...
并查集详解与应用：等价类问题解决
"这篇内容主要介绍了并查集算法思想及其在等价类问题中的应用，通过实例展示了如何利用并查集解决元素集合合并的问题。" 并查集是一种数据结构，主要用于处理一些不相交集合的合并与查询问题。在算法设计中，它尤其...
并查集（用于给信息划分等价类）例题实现
qq_45783112的博客
11-21 527
使用father数组，为根时存放权值的相反数（为了区分成员的根），不为根时存放father，f区分根和非根：father为正或者为负 makeset：获得n颗树，权值 find：寻找成员根结点，如果该成员不是根（避免误伤权值）就并将成员链接到根节点上 union：比较权值，将权值小的链接到权值大的上面去，维护权值 下面用一道例题来展现并查集的makeset，find，union和寻找两个元素是否在同一个等价类中的基本实现 有n台计算机，编号为1到n。设定如果计算机a和计算机b
"探索集合与字典：计算机科学中的散列集合、并查集与等价类
Chapter 5 introduces sets and dictionaries, two important data structures in computer science. Sets are collections of unique elements, while dictionaries are collections of key-value pairs....
并查集的表示与等价分类
hit_fantasy的专栏
03-26 954
最简单的实现，为了凑软件设计作业。。。没有做优化。 #include #include using namespace std; //equivalence means deng jia lei class equivalence { protected: int *parent; int size; int find(int cur)const; public:
并查集经典扩展-pku1182(食物链)-并查集用于等价类问题
train的专栏
04-14 1534
 并查集的普通应用包括，计算最小生成树的kruscal算法和无向图的连通性问题。这个题目是并查集的一个扩展应用，用于解决等价类问题。  问题描述:动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。 有人用两种说法对这N个动物所构成
【数据结构】并查集
最新发布
Code Space
09-11 2179
介绍了并查集的概念，并模拟实现了并查集。
并查集
ccshijtgc的专栏
01-17 1718
并查集是一种特殊的集合，由一些不相交子集构成，合并查集的基本操作是： Find：判断两个结点是否在同一个集合中 Union：归并两个集合 因此可以将并查集中每个结点只保存一个指向其父结点的指针域，通过判断节点的父指针是否相同可以判断2个节点是否是同一个并查集 用父指针表示的树形结构实现的并查集可以很容易地解决等价类问题: 1、约定森林F={T1，T2，…，Tr}表
计算等价类
sytloveyxj的博客
10-09 6741
首先，什么是等价关系： 等价关系是集合元素间的一种代数关系,用字母E来表示，对于一个集合中的两个元素，如果他们之间存在一种等价关系，那么必须满足以下性质： 1.  自反性，对于任意一个元素x, 它与自己存在等价关系，即(x,x) 满足E 2.  对称性，如果(x,y) 满足 E, 那么 (y, x) 也属于E 3.  传递性，如果(x,y) 满足 E,(y,z)满足E,那么(x,z)也
并查集的分析及应用
凌风
01-27 4100
并查集的分析及简单应用，个人理解并作记录之用。 ————凌风 CSDN
并查集(union-find)算法学习笔记
ziggyPLAYguitar的博客
09-15 822
输入一列整数队，一对整数可以被理解为这整数两个对象是互相连接的，且其中每个对象都属于一个等价类，若两个对象直接相连或者间接相连时它们属于同一个等价类。   这样的等价关系能将这些整数分为多个等价类。 如图中所示，首先是0到9有10个互不关联的对象，有10个等价类。 首先输入（4，3），将4和3相连，此时4，3属于同一个等价类，此时有9个等价类。 输入（3，8），8加入4和3
数据结构-第七章 并查集
SpriCoder的博客
02-19 461
第七章 并查集
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值