[cpp] view plaincopy

1. int parent[100];
2. //构造一个初始并查集，s是集合元素的个数，此时初始化了s个集合，每一个集合都只有一个元素
3. //数组的范围为parent[0]~parent[s-1]
4. //初始的时候，数组元素的值都是 -1，表示此时都是根结点。
5. void ufset(int s)
6. {
7. int si=s;
8. for(int i=0;i<si;i++)
9. parent[i]=-1;
10. }

二、合并Union

[cpp] view plaincopy

1. //集合的合并
2. //让root2的父指针指向root1即可实现两个集合的合并
3. void Union(int root2,int root1)
4. {
5. parent[root1]+=parent[root2];
6. parent[root2]=root1;
7. }

举个例子：初始化10个元素（如上图所示），进行下面的合并过程：

[cpp] view plaincopy

1. ufset(10);  //初始化10个元素
2. Union(6,0);
3. Union(7,0);
4. Union(8,0);
5. Union(4,1);
6. Union(9,1);
7. Union(3,2);
8. Union(5,2);

合并之后的结果：

[cpp] view plaincopy

1. //使用加权规则得到改进的Union操作
2. void WeightUnion(int root2,int root1)
3. {
4. int r2=Find(root2);  //r2和r1是root2和root1的父结点
5. int r1=Find(root1);
6. int temp;
7. if(r1!=r2)
8. {
9. temp=parent[r1]+parent[r2];
10. if(parent[r1]<parent[r2]){parent[r1]=temp;parent[r2]=r1;}  //以r2根的树结点多
11. else {parent[r1]=r2;parent[r2]=temp;}
12. }
13. }

[cpp] view plaincopy

1. //使用加权规则得到改进的Union操作
2. void WeightUnion(int root2,int root1)
3. {
4. int r2=Find(root2);  //r2和r1是root2和root1的父结点
5. int r1=Find(root1);
6. int temp;
7. temp=parent[r1]+parent[r2];
8. if(parent[r1]<=parent[r2])
9. //注意：parent[r1] 和 parent[r2] 都是负数，所以小者其绝对值大，那么拥有的结点数就多
10. //这里就说明 r1为根的树结点  不少于  r2为根的树结点
11. {
12. parent[r1]=temp;    //以r1为根
13. parent[r2]=r1;
14. }
15. else
16. {
17. parent[r1]=r2;
18. parent[r2]=temp;
19. }
20. }

[cpp] view plaincopy

1. //查找元素x所在集合
2. //从x开始，沿父指针链一直向上，直到向上，直到达到一个父指针域为负值的结点位置
3. int Find(int x) //迭代查找方式
4. {
5. while(parent[x]>=0) x=parent[x];
6. return x;
7. }
8. /*
9. int find_1(int x)  //递归查找方式
10. {
11. if(parent[x]<0) return x;  //x是根时，直接返回x
12. else return find_1(parent[x]);  //否则，递归找x的父的根
13. }
14. */

进一步优化，在查找过程中可以采用折叠规则压缩路径。

[cpp] view plaincopy

1. //折叠规则压缩路径法
2. //包含元素i的树中搜索根，并将从元素i到根的路径上的所有结点都变成根的结点
3. int collapsingfind(int i)
4. {
5. int j;
6. for(j=i;parent[j]>=0;j=parent[j]); //搜索j的根
7. while(i!=j)   //向上逐次压缩
8. {
9. int temp=parent[i];
10. parent[i]=j;
11. i=temp;
12. }
13. return j;  //返回根
14. }

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. int parent[100];
4. //构造一个初始并查集，s是集合元素的个数，此时初始化了s个集合，每一个集合都只有一个元素
5. //数组的范围为parent[0]~parent[s-1]
6. //初始的时候，数组元素的值都是 -1，表示此时都是根结点。
7. void ufset(int s)
8. {
9. int si=s;
10. for(int i=0;i<si;i++)
11. parent[i]=-1;
12. }
13. //查找元素x所在集合
14. //从x开始，沿父指针链一直向上，直到向上，直到达到一个父指针域为负值的结点位置
15. int Find(int x) //迭代查找方式
16. {
17. while(parent[x]>=0) x=parent[x];
18. return x;
19. }
20. /*
21. int find_1(int x)  //递归查找方式
22. {
23. if(parent[x]<0) return x;  //x是根时，直接返回x
24. else return find_1(parent[x]);  //否则，递归找x的父的根
25. }
26. */
27. //折叠规则压缩路径法
28. //包含元素i的树中搜索根，并将从元素i到根的路径上的所有结点都变成根的结点
29. int collapsingfind(int i)
30. {
31. int j;
32. for(j=i;parent[j]>=0;j=parent[j]); //搜索j的根
33. while(i!=j)   //向上逐次压缩
34. {
35. int temp=parent[i];
36. parent[i]=j;
37. i=temp;
38. }
39. return j;  //返回根
40. }
41. //集合的合并
42. //让root2的父指针指向root1即可实现两个集合的合并
43. void Union(int root2,int root1)
44. {
45. parent[root1]+=parent[root2];
46. parent[root2]=root1;
47. }
48. //使用加权规则得到改进的Union操作
49. void WeightUnion(int root2,int root1)
50. {
51. int r2=Find(root2);  //r2和r1是root2和root1的父结点
52. int r1=Find(root1);
53. int temp;
54. if(r1!=r2)
55. {
56. temp=parent[r1]+parent[r2];
57. if(parent[r1]<parent[r2]){parent[r1]=temp;parent[r2]=r1;}  //以r2根的树结点多
58. else {parent[r1]=r2;parent[r2]=temp;}
59. }
60. }
61. int main()
62. {
63. ufset(10);  //初始化10个元素
64. Union(6,0);
65. Union(7,0);
66. Union(8,0);
67. Union(4,1);
68. Union(9,1);
69. Union(3,2);
70. Union(5,2);
71. for(int i=0;i<10;i++) cout<<parent[i]<<" ";
72. return 0;
73. }