不相交集类

转载请注明出处:https://i.cnblogs.com/EditPosts.aspx?postid=5748920

一、基本概念

不相交集类维持着多个彼此之间没有交集的子集的集合,可以用于 判断两个元素是否属于同一个集合,或者合并两个不相交的子集。比如,

                                         { {1,3,5},{2},{4},{6,7} }

这整体就是一个不相交集合。里面的一些子集也是彼此互不相交的。

注意,对于每一个子集,往往用某一个元素来代表,至于用哪一个元素来表示则没有硬性要求。只要能够保证对于某一个子集中的元素查找两次它的代表,返回的值是相同的即可。还是上面的例子,

假设 1作为第一个子集的代表,find(1)、find(3)、find(5)都应该返回 1。而如果find(1)返回的是 1,find(3)返回的是 3,我们就可能认为两个元素不在同一个集合里,而事实并不是这样。

对于不相交集类,我们重点关注以下三个操作:

1.makeSet(x),建立一个新的只含有元素 x的集合。

2.union(x,y),将 x、y所在的子集(Sx和 Sy)合并成一个新的子集,并为了保证新集合的子集不相交性,消除原来集合中的 Sx和 Sy。

3.find(x),返回元素 x所在的集合的代表。

二、不相交集类的链表表示

使用链表来表示不相交集类是比较简单的。对于链表中的每一个对象,包含一个数据成员,指向所在集合的代表的指针和指向下一个节点的指针,如图 1所示。

每一个子集用一个链表表示,链表中的第一个节点代表了当前子集。另外,对于每一个链表,还设置了 head指针和 tail指针。其中, head指针指向当前子集的代表,tail指针则指向当前子集的最后一个元素,如图 2所示。

下面来分析使用这样的数据结构,其操作是如何完成的和其时间复杂度如何。

1.makeSet(x),只需要建立一个只含有元素值x的节点的链表,时间复杂度为 O(1)。

2.find(x),只需要返回其所指向的代表指针所指向的节点的数据成员即可,时间复杂度为 O(1)。

3.union(x,y),根据合并时所采用的策略,可以分为两种

3.1 将 x所在的链表合并到 y所在的链表中

此时,合并后的链表是以 y链表的第一个节点作为当前集合的代表的,这样就需要将原来 x链表的指向代表的指针都修改为指向 y链表的第一个节点,修改次数与 x链表的长度一致。如图 3所示。

假设含有 n个不相交子集的集合 S,初始状态下每个集合都只含有一个元素 xi。

第一次,执行 union(x1,x2),需要 1次操作;

第二次,执行 union(x2,x3),需要 2次操作;

......

第 i次,执行 union(xi,xi+1),需要 i次操作;

......

第 n-1次,执行 union(xn-1,xn),需要 n-1次操作;

由于总的元素子集个数只有 n个,所以 union的最大次数为 n-1。这样,对于连续 n-1次 union,总的操作次数为 1+2+...+n-1 = O(n2)。平均来看,每一次 union操作的摊还时间为 O(n)。

3.2 加权合并启发式策略——将较短的表拼到较长的表上去

仔细分析上文所述的对于含有 n个不相交子集的集合 S的合并过程,可以发现在执行 union(xi,xi+1)时,将 xi链合并到 xi+1链中,需要 i次操作,而将  xi+1链合并到 xi链中,则只需要 1次操作。那么对于连续 n-1次从 x1到 xn的union,总的操作次数只有 n-1。

这也许是合并 n个不相交子集的集合 S的最好情形,而最坏情形就是 3.1中所描述的做法。

然而实际合并时,并不总是会有包含 x1的子集,还会有其他多种情况,比如将 {x2,x3}和{x4,x5,x6}合并到一起。但是这给了我们一个启发,就是在合并时,将较短的表拼到较长的表上去,以此来减少修改指向代表的指针的次数。

对于某一个元素 x,一开始它是一个独立的子集,其代表指针指向子集。

当第一次修改它的代表指针,使它指向别的元素时,说明 {x}与其它子集合并了,此时新集合的元素个数至少是 2;

当第二次修改它的代表指针,说明与其合并的子集的元素个数至少为 2,那么此时新集合的元素个数至少是 4;

......

当第 k次修改它的代表指针,说明与其合并的子集的元素个数至少为 2k-1,那么此时新集合的元素个数至少是 2k;

由于总的元素子集个数只有 n个,所以最多修改 lgn次元素 x的代表指针。所以将 n个元素 union到一起,最坏情形下总共需要 nlgn次操作。即,其时间复杂度为  O(nlgn)。而最好情形则是本节一开始所说的 O(n)。

不过,对于链表表示,有一个很大的问题。就是以上的分析都是直接基于节点的,而不是基于节点的数据成员。比如,对于图 2中的 find(5),理论分析只需要返回它的代表指针即可;可是一开始并不能知道 5节点在哪里,还是需要先遍历当前链表,找到数据成员为 5的节点。

这样一来,时间复杂度将会增加很多,实现起来也变得麻烦了。所以这里我并没有给出链表实现的代码。(PS:这是我自己的疑问,希望各位高手能帮我解答这个疑惑,谢谢

三、不相交集类的根树表示

 使用一棵树来表示一个子集,树的根节点可以代表当前子集,而所有子集的集合就是一个森林。而对于根树的存储结构,采用数组实现。s[i]表示元素 i的父节点。根节点令 s[i]=-1。

注意,下面这个例子以及后面的图会与测试中采用的数据和方法相一致,可以用来检测所编写程序的正确性!

图 4 含有 10个单元素子集的根树表示和存储结构

同样地,现在来考虑操作是如何完成的和其时间复杂度如何。

1.makeSet(x),令 x成为只含有根节点的树,并且令 s[x] = -1。

2.union(x,y),用根树表示的不相交子集在合并时时很容易且快速的。这里,假设 x和 y都是根节点(不是的话,可以通过find()返回其所在树的根节点)。简单的做法是将 y的父链连接到 x节点上,比如 union(6,7),图 4变成了下面图 5所示的情形.

图 5 union(6,7)

接着,union(4,5),有

图 6 union(4,5)

然后,再 union(4,6),有

图 7 union(4,6)

可以看到,前面的合并方法是相当随意的,它通过使第二颗树成为第一颗树的子树而完成合并。这样做有一个隐患,那就是这可能会导致某些树的深度增加过大,从而增加 find()操作的时间复杂度。

这里,采用两种灵巧求并算法来完成合并操作。

2.1 按大小求并

合并的时候先检查树的大小,使较小的树成为较大的数的子树。这样的话,需要在根节点处记录每一颗树的大小。由于已经令根节点的 s[i]=-1了,这里,可以直接用根节点的 s[i]存储树的大小。而当按大小合并时,将较小树的大小加到较大树上去,并且令较小树的父链指向较大树的根节点。

下图比较了再执行 union(3,4)时随意合并与按大小求并的结果有何不同。

图 8 使第二颗树成为第一颗树的子树而完成合并  图 9 按大小求并

2.2 按高度(秩)求并

 按高度求并可以看做是按大小求并的简单修改,因为对于根树结构,节点个数多并不意味着高度就越大。对于以下两棵树而言,使用按高度求并得到的结果深度更小。

;按大小求并,有

;按高度求并,有

                            图 10 按大小合并与按高度合并的区别

同样地,在合并两颗树时,将高度较小的树合并到高度较大的树中。只有在两颗子树的高度相同时,新树的高度才会增加 1。同样地,此时根节点的 s[i]存储的是树的高度。当树中只有一个根节点时,s[i]=-1;而当树的高度增 1的时候,使用 --操作符,因为此时采用的是树的高度的相反数。

使用按高度求并,执行 union(3,4),有

图 11 union(4,6)

3.find(x),寻找节点 x所在的树的根节点。一般来说,不停地通过父链向上寻找,就可以找到 x所在的树的根节点。这里,可以进行一些改进,在执行 find(x)的过程中同时实现路径压缩。即从 x到根节点的路径上的每一个节点都使它的父节点变成根。

如对上图执行完 find(7)后,有

图 12 执行完 find(7)后的不相交集和

可以看到,此时树的高度有所下降。另外,对于数组中 s[4]=-3,这里采用的是上图中的按高度求并。你也许可能会有疑问说,此时节点 4的高度为 2,为什么 s[4]=-3?接下来就来回答这个问题。

在随意执行 union操作时,单单使用路径压缩,连续 M次操作最多需要 O(MlgN)的时间。

路径压缩与按大小求并是完全兼容的,这就使得两个例程可以同时实现。时间复杂度如何?

而按高度求并不完全与路径压缩兼容,因为路径压缩会改变树的高度,而计算新的高度并不容易。怎么办呢?做法就是不计算,仍旧存储没有实行路径压缩之前的高度。注意,这个高度并不是树的真实高度,而是一个估计高度,称为秩。

按秩求并和路径压缩单独实行也能改善运行时间,但一起使用可以大幅度改善运行时间。最坏运行时间为 O(mα(n)),其中α(n)是一个增长极其缓慢的函数,在大多数不相交集的应用中,都会有 α(n)≤4。因此这个运行时间接近于 O(m)。

四、不相交集类的根树实现

完整的 C++代码及测试代码如下,这里的 unionSets操作分别采用了任意合并、按大小求并和按高度求并三种方式,而 find操作则使用了简单查找(没有任何额外操作)和路径压缩两种方式。

 1 /* 
 2 * DisjSets.h文件,DisjSets类的声明部分
 3 * 1.注意,这里实现的不相交集类是采用根树表示、数组存储的,这就带来一个问题,对于一个节点值为 x的根节点,
 4 *   有 s[x]=-1。可如果数据只有 1,2,100这 3个数,却需要建立一个长度为 101的数组,是不是有些浪费了呢?
 5 * 2.unionSets操作分别采用了任意合并、按大小求并和按高度求并三种方式,而 find操作则使用了简单查找(没有任何额外操作)和路径压缩两种方式。
 6 * @author 塔奇克马              @data 2016.08.08
 7 */
 8 
 9 #pragma once
10 #include <vector>
11 using namespace std;
12 
13 class DisjSets
14 {
15 public:
16     explicit DisjSets(int maxNum);
17     ~DisjSets();
18 
19     // 简单查找,没有像路径压缩之类的额外操作
20     int find(int x) const;
21     // 使用了路径压缩的查找操作
22     int findWithPassCompression(int x);
23     // 一般形式的查找操作,flag为 false,使用简单查找;反之则使用了路径压缩
24     int find(int x, bool flag);
25     // 任意合并,将 y树作为 x的子树完成合并
26     void unionSets(int x, int y, bool flag = true);
27     // 按大小求并
28     void unionSetsBySize(int x, int y, bool flag = true);
29     // 按高度求并
30     void unionSetsByHeight(int x, int y,  bool flag = true);
31     // 按类打印出整个不相交集合
32     void print() const;
33 private:
34     // 打印出根节点为 x的整个树
35     void print(int x) const;
36     vector<int> s;  // 存储整个不相交集
37 };
  1 // DisjSets.cpp文件,DisjSets类的实现部分
  2 
  3 #include "iostream"
  4 #include "DisjSets.h"
  5 using namespace std;
  6 
  7 DisjSets::DisjSets(int maxNum):s(maxNum)
  8 {
  9     for (int i=0; i<maxNum; i++)
 10     {
 11         s[i] = -1;
 12     }
 13 }
 14 
 15 DisjSets::~DisjSets()
 16 {
 17 
 18 }
 19 
 20 
 21 // 简单查找,没有像路径压缩之类的额外操作
 22 int DisjSets::find(int x) const
 23 {
 24     if (s[x] < 0)
 25         return x;
 26     else
 27         return find( s[x] );
 28 }
 29 
 30 // 使用了路径压缩的查找操作
 31 int DisjSets::findWithPassCompression(int x)
 32 {
 33     if (s[x] < 0)
 34         return x;
 35     else
 36         return s[x] = find( s[x] );
 37 }
 38 
 39 // 一般形式的查找操作,flag为 false,使用简单查找;反之则使用了路径压缩
 40 int DisjSets::find(int x, bool flag)
 41 {
 42     if (!flag)
 43         return find(x);
 44     else
 45         return findWithPassCompression(x);
 46 }
 47 
 48 // 任意合并,将 y树作为 x的子树完成合并
 49 void DisjSets::unionSets(int x, int y, bool flag)
 50 {
 51     x = find(x,flag); y = find(y,flag);
 52     s[y] = x;
 53 }
 54 
 55 // 按大小求并
 56 void DisjSets::unionSetsBySize(int x, int y, bool flag)
 57 {
 58     x = find(x,flag); y = find(y,flag);
 59     if ( s[x] <= s[y] )   // x树更大,令 y树成为 x的子树
 60     {
 61         s[x] += s[y];
 62         s[y] = x;
 63     }
 64     else
 65     {
 66         s[y] += s[x];
 67         s[x] = y;
 68     }
 69 }
 70 
 71 // 按高度求并
 72 void DisjSets::unionSetsByHeight(int x, int y, bool flag)
 73 {
 74     x = find(x,flag); y = find(y,flag);
 75     if ( s[x] > s[y] )   // y树更深,令 x树成为 y的子树
 76         s[x] = y;
 77     else
 78     {
 79         if ( s[x] == s[y] )
 80             s[x]--;
 81         s[y] = x;
 82     }
 83 }
 84 
 85 // 按类打印出整个不相交集合
 86 void DisjSets::print() const
 87 {
 88     cout<<"整个不相交集的全部元素为: "<<endl;
 89     for (unsigned int i=0; i<s.size(); i++)
 90         cout<<i<<"  ";
 91     cout<<endl;
 92     int numOfChildSets = 0;
 93     for (unsigned int i=0; i<s.size(); i++)
 94     {
 95         if ( s[i] < 0 )
 96         {
 97             cout<<"第 "<<++numOfChildSets<<"个子集: ";
 98             print( i );
 99             cout<<endl;
100         }
101     }
102     cout<<"总共有 "<<numOfChildSets<<"个子集"<<endl;
103     cout<<"s中的元素值:"<<endl;
104     for (unsigned int i=0; i<s.size(); i++)
105         cout<<s[i]<<"  ";
106     cout<<endl;
107 }
108 
109 // 打印出根节点为 x的整个树
110 void DisjSets::print(int x) const
111 {
112     cout<<x<<"  ";
113     for (unsigned int j=0; j<s.size(); j++)
114     {
115         if ( x == s[j] )
116             print(j);
117     }
118 }
 1 #include "iostream"
 2 #include "DisjSets.h"
 3 using namespace std;
 4 
 5 void main()
 6 {
 7     DisjSets  disjSets(10);
 8     disjSets.print();
 9 
10 ////////////随意合并//////////////////
11     disjSets.unionSets(6, 7, false);
12     disjSets.unionSets(4, 5, false);
13     disjSets.unionSets(4, 6, false);
14     disjSets.unionSets(3, 4, false);
15     disjSets.print();
16 
17 //////////////按大小合并//////////////////
18     disjSets.unionSetsBySize(6, 7, false);
19     disjSets.unionSetsBySize(4, 5, false);
20     disjSets.unionSetsBySize(4, 6, false);
21     disjSets.unionSetsBySize(3, 4, false);
22     disjSets.print();
23 
24 ////////////按高度合并//////////////////
25     disjSets.unionSetsByHeight(6, 7, false);
26     disjSets.unionSetsByHeight(4, 5, false);
27     disjSets.unionSetsByHeight(4, 6, false);
28     disjSets.unionSetsByHeight(3, 4, false);
29     disjSets.print();
30 
31     disjSets.findWithPassCompression(7);
32     disjSets.print();
33 
34     system("pause");
35 }

下面是测试代码的输出结果:

  与图 4结果一致    

  与图 8结果一致  

  与图 9结果一致  

  与图 11结果一致       

    与图 12结果一致                                                        

总的来说,不相交集类是一种很有意思的数据结构。它实现起来简单、快速,但其时间复杂度的分析却相当困难。我看到《算法导论》和《数据结构与算法分析C++描述》中关于它的分析都很复杂,并且有些地方的结论也不太相同。所以,这里我也不敢乱言。

对了,不相交集类可以用来生成迷宫,确定无向图中连通子图的个数等。

五、利用不相交集生成迷宫

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏算法修养

CodeForces 19D Points (线段树+set)

D. Points time limit per test 2 seconds memory limit per test 256 megabyte...

3699
来自专栏HTML5学堂

游戏开发 - Math对象相关知识讲解

前几期小编给大家总结了JavaScript的基础知识,为我们后期深入学习JS打下了一定的基础。在后面的几期文章当中我们要来进行JS小游戏的开发,但是开发小游戏的...

29710
来自专栏架构之路

一条直线上N个线段所覆盖的总长度

转自http://blog.csdn.net/bxyill/article/details/8962832 问题描述: 现有一直线,从原点到无穷大。 这条直线上...

3645
来自专栏深度学习思考者

一文搞懂算法的时间复杂度与空间复杂度

一 时间复杂度的概念   一般情况下,算法的基本操作重复执行的次数是模块n的某一函数f(n),因此,算法的时间复杂度记做 T(n) = O(f(n))。 随着模...

7598
来自专栏CDA数据分析师

学会这8个(组)excel函数,轻松解决工作中80%的难题

文 | 兰色幻想-赵志东 函数是excel中最重要的分析工具,面对400多个excel函数新手应该从哪里入手呢?下面是实际工作中最常用的8个(组)函数,学会后工...

1967
来自专栏chenjx85的技术专栏

leetcode-78-子集(用bfs解决)

vector<vector<int>> subsets(vector<int>& nums)

4361
来自专栏tkokof 的技术,小趣及杂念

sizeof 知多少?

稍熟悉C/C++的朋友,对于sizeof肯定不陌生,通过他我们可以知晓某个类型或者实例的内存大小(以字节计),但是如果深入一下sizeof计算的细节,想来大部分...

720
来自专栏用户2442861的专栏

对vector等STL标准容器进行排序操作

STL几乎封装了所有的数据结构中的算法,从链表到队列,从向量到堆栈,对hash到二叉树,从搜索到排序,从增加到删除......可以说,如果你理解了STL,你会...

2572
来自专栏锦小年的博客

Python数据分析(2)-pandas数据结构操作

pandas是一个提供快速、灵活、表达力强的数据结构的Python库,适合处理‘有关系’或者‘有标签’的数据。在利用Python做数据分析的时候,pandas是...

26110
来自专栏数据小魔方

左右用R右手Python9——字符串合并与拆分

在文本处理和数据清洗阶段,对字符串或者字符型变量进行分割、提取或者合并虽然谈不上什么高频需求,但是往往也对很重要的。 接下来跟大家大致盘点一下在R语言与Pyh...

3515

扫码关注云+社区

领取腾讯云代金券