转载请注明出处：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操作则使用了简单查找（没有任何额外操作）和路径压缩两种方式。
代码语言：javascript复制 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 描述》中关于它的分析都很复杂，并且有些地方的结论也不太相同。所以，这里我也不敢乱言。
对了，不相交集类可以用来生成迷宫，确定无向图中连通子图的个数等。
