用于不相交集合的数据结构（并查集）

不相交集合数据结构的概念和操作：

    不相交集合数据结构（disjoing-set data structure)保持一组不相交的动态集合S={S1，S2，S3，……Sk}。每个集合通过一个代表来识别，代表即集合中的某个成员。

我们希望不相交集合数据结构支持如下操作：

1 . MAKE_SET(x)： 建立一个新的集合，其唯一成员就是x，所以其代表也就是自己。因为各集合是不相交的，故要求x没有在其他集合中出现过。

2 . UNION(x，y)： 将包含x和y的动态集合（比如说Sx和Sy）合并为一个新的集合（即这两个集合的并集）。假定这个操作之前是不相交的。在经过此操作后，所得集合的代表可以是Sx U Sy中的任何一个成员，但在UNION的很多实现细节中，都选择Sx或Sy的代表作为新的代表。由于要求各集合是不相交的，故我们“消除”集合Sx和Sy，把它们从S中删去。

3 . FIND_SET(x)：返回一个指针，指向包含x的（唯一）集合的代表。

不相交数据集合一般用链表或森林（有根树，如下图）来实现，有根树的速度更快。用有根树来表示集合，树中的每个节点都包含集合的一个成员，每棵树都表示一个集合。从下图中可知，不相交森林中，每个成员仅指向其父节点。每个树的根包含了代表，并且是它自己的父节点。尽管采用了这种表示的直观算法并不比采用链表表示的直观算法并不比采用链表表示的算法更快，但是，通过引入两种启发式策略（“按秩合并”和“路径压缩”），就可以获得目前已知的，渐进意义上最快的不相交集合的数据结构。

改进运行时间的启发式策略：

1.按秩合并，其思想是是5包含较少节点的树的根指向包含较多节点的树的根。我们并不显示的记录以每个节点为根的子树大小，而是采用了一种能够简化分析的方法。对每个节点，用秩表示节点高度的一个上届。在按秩合并中具有较小秩的根在UNION操作中要指向具有较大秩的根。

2.路径压缩，它非常简单而有效。如下图所示，在FIND_SET操作中，利用这种启发式策略，来使查找路径上的每个节点都直接指向根节点。路径压缩并不改变节点的秩。

不相交集合森林的伪代码：

带路径压缩的FIND_SET过程也是相当简单的：

过程FIND_SET是一种两趟方法，也就是说它干了两件事：

1.沿着路径上升，找到代表。

2.修改路径上的元素的p域，使其指向代表。

代码示例：

1. #include <stdio.h>  
2. const int MAXN = 100;  
3. int pa[MAXN];  
4. int rank[MAXN];  
5.   
6. void make_set(int x)  
7. {//create a set  
8.     pa[x] = x;  
9.     rand[x] = 0;  
10. }  
11.   
12. int find_set( int x)  
13. {/*带压缩路径的查找 */  
14.     if( x != pa[x] )  
15.     {  
16.         pa[x] = find_set(pa[x]);  
17.     }  
18.     return pa[x];  
19. }  
20.   
21. void link( int x, int y)  
22. {  
23.     if( rank[x] > rank[y])  
24.     {  
25.         pa[y] = x;  
26.     }  
27.     else  
28.     {  
29.         pa[x] = y;  
30.         if( rank[x] == rank[y])  
31.         {  
32.             rank[y]++;  
33.         }  
34.     }  
35. }  
36. void union_set(int x, int y)  
37. {  
38.     link(find_set(x),find_set(y));  
39. }     

不相交集合数据结构的一个应用：

    不相交集合数据结构有多种应用，其中之一是用于确定一个无向图中连通子图的个数。在下面给出的过程CONNECTED_COMPONENTS中，利用了不相交集合操作来计算一个图的连通子图。一旦CONNECTED_COMPONENTS作为预处理步骤执行后，过程SAME_COMPONENT回答两个顶点是否在同一连通子图的查询。

SAME_COMPONENT(u, v)

1  if FIND_SET(u) = FIND_SET(v)

2        then return TRUE

3        else return FALSE

代码示例：

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <iostream>  
4. using namespace std;  
5. const int MAXN = 100;  
6. const int NODE_NUM = 10;  
7. int pa[MAXN];  
8. int rank[MAXN];  
9.   
10. void make_set(int x)  
11. {//create a set  
12.     pa[x] = x;  
13.     rank[x] = 0;  
14. }  
15.   
16. int find_set( int x)  
17. {/*带压缩路径的查找 */  
18.     if( x != pa[x] )  
19.     {  
20.         pa[x] = find_set(pa[x]);  
21.     }  
22.     return pa[x];  
23. }  
24.   
25. void link( int x, int y)  
26. {  
27.     if( rank[x] > rank[y])  
28.     {  
29.         pa[y] = x;  
30.     }  
31.     else  
32.     {  
33.         pa[x] = y;  
34.         if( rank[x] == rank[y])  
35.         {  
36.             rank[y]++;  
37.         }  
38.     }  
39. }  
40. void union_set(int x, int y)  
41. {  
42.     link(find_set(x),find_set(y));  
43. }     
44.   
45. bool same_components( int u, int v)  
46. {  
47.     if( find_set(u) == find_set(v))  
48.     {  
49.         return true;  
50.     }  
51.     else  
52.     {  
53.         return false;  
54.     }  
55. }  
56. int connected_components(const int node,const  int adj[][NODE_NUM])  
57. {  
58.     int i = 0;  
59.     int j = 0;  
60.     int count = 0;  
61.     for( i = 0; i < node; i++)  
62.     {  
63.         make_set(i);  
64.     }  
65.     for( i = 0; i < node; i++)  
66.     {  
67.         for( j = i + 1; j < node; j++ )  
68.         {  
69.             if( adj[i][j] != 0 && find_set(i) != find_set(j) )  
70.             {  
71.                 union_set(i, j);  
72.             }  
73.         }  
74.     }  
75.   
76.     int *p = new int[node];  
77.     memset(p, 0, sizeof(int) * node );  
78.     for( i = 0; i < node; i++)  
79.     {  
80.         for( j = 0; j < count; j++)  
81.         {  
82.             if( find_set(i) == find_set(p[j]))  
83.             {  
84.                 break;  
85.             }  
86.         }  
87.         if( j >= count )  
88.         {  
89.             p[count++] = i;  
90.         }  
91.   
92.     }  
93.     delete[] p;  
94.     p = NULL;  
95.     return count;  
96. }  
97.   
98.   
99.   
100.   
101.   
102. int main(int argc, char* argv[])  
103. {  
104.     const int adj[NODE_NUM][NODE_NUM] = {  
105.         {0, 1, 1, 0, 0, 0, 0, 0, 0, 0},  
106.         {1, 0, 1, 1, 0, 0, 0, 0, 0, 0},  
107.         {1, 1, 0, 0, 0, 0, 0, 0, 0, 0},  
108.         {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},  
109.         {0, 0, 0, 0, 0, 1, 1, 0, 0, 0},  
110.         {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},  
111.         {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},  
112.         {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},  
113.         {0, 0, 0, 0, 0, 0, 0, 1, 0, 0},  
114.         {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};  
115.   
116.     cout << "连通子图的个数：" << connected_components( NODE_NUM, adj) << endl;  
117.     return 0;  
118. }