算法导论-用于不想交集合的数据结构（并查集）-kruskal最小生成树算法

并查集学习：

并查集：(union-find sets)

一种简单的用途广泛的集合. 并查集是若干个不相交集合，能够实现较快的合并和判断元素所在集合的操作，应用很多，如其求无向图的连通分量个数等。最完美的应用当属：实现Kruskar算法求最小生成树。

并查集的精髓（即它的三种操作，结合实现代码模板进行理解）：

1、Make_Set(x) 把每一个元素初始化为一个集合
初始化后每一个元素的父亲节点是它本身，每一个元素的祖先节点也是它本身（也可以根据情况而变）。
2、Find_Set(x) 查找一个元素所在的集合
查找一个元素所在的集合，其精髓是找到这个元素所在集合的祖先！这个才是并查集判断和合并的最终依据。
判断两个元素是否属于同一集合，只要看他们所在集合的祖先是否相同即可。
合并两个集合，也是使一个集合的祖先成为另一个集合的祖先，具体见示意图
3、Union(x,y) 合并x,y所在的两个集合
合并两个不相交集合操作很简单：
利用Find_Set找到其中两个集合的祖先，将一个集合的祖先指向另一个集合的祖先。如图



并查集的优化

1、Find_Set(x)时 路径压缩
寻找祖先时我们一般采用递归查找，但是当元素很多亦或是整棵树变为一条链时，每次Find_Set(x)都是O(n)的复杂度，有没有办法减小这个复杂度呢？
答案是肯定的，这就是路径压缩，即当我们经过"递推"找到祖先节点后，"回溯"的时候顺便将它的子孙节点都直接指向祖先，这样以后再次Find_Set(x)时复杂度就变成O(1)了，如下图所示；可见，路径压缩方便了以后的查找。
2、Union(x,y)时 按秩合并
即合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。



代码实现并查集：

void makeSet()//初始化集合
{
for(int i=0;i<n;i++)
{
father[i]=i;
rank[i]=0;
}
}
int findSet(int x)//寻找x所在集合，回溯时压缩路径
{
if(x!=father[x])
father[x]=findSet(father[x]);
return(father[x]);
}

//按秩合并x和y所在的集合，合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。
void unionSet(int x,int y)
{
if(rank[x]>rank[y])
father[y]=x;
else if(rank[x]<rank[y])
father[x]=y;
else
{
rank[y]++;
father[x]=y;
}
}

在Kruskal算法中的具体应用：

#include<stdio.h>
#include<stdlib.h>
#define n 9//图中点的个数
#define max 100
struct edge{
int u;//起点
int v;//终点
int value;//边的权值
}e[max];
int p[max];//用于记录最小生成树的边
int father
;//father[x]表示x的父节点；
int rank
;//rank[x]表示x的秩，从x到其某一后代叶节点的最长路径上边的数目，即树的高度
int cmp(const void *a,const void *b)
{
return ((*(edge*)a).value > (*(edge*)b).value ? 1:-1);
}
/*----------------------并查集的基本操作--------------------------*/
void makeSet()//初始化集合
{
for(int i=0;i<n;i++)
{
father[i]=i;
rank[i]=0;
}
}
int findSet(int x)//寻找x所在集合，回溯时压缩路径
{
if(x!=father[x])
father[x]=findSet(father[x]);
return(father[x]);
}

//按秩合并x和y所在的集合，合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。
void unionSet(int x,int y)
{
if(rank[x]>rank[y])
father[y]=x;
else if(rank[x]<rank[y])
father[x]=y;
else
{
rank[y]++;
father[x]=y;
}
}
/*-----------------------------主函数-------------------------------*/
int main()
{
int i,j,x,y,h=0,sum=0,k=0;//k记录边的个数
//en表示各个点之间的连接情况，为0表示无边，其他值表示边的权值
//这里en是无向图
int en

={
{0,4,0,0,0,0,0,8,0},
{4,0,8,0,0,0,0,11,0},
{0,8,0,7,0,4,0,0,2},
{0,0,7,0,9,14,0,0,0},
{0,0,0,9,0,10,0,0,0},
{0,0,4,14,10,0,2,0,0},
{0,0,0,0,0,2,0,1,6},
{8,11,0,0,0,0,1,0,7},
{0,0,2,0,0,0,6,7,0}};

for(i=0;i<n;i++)//各个边的初始化，将边全部存储在e[]数组中
for(j=i;j<n;j++)
{
if(en[i][j]!=0)
{
e[k].u=i;
e[k].v=j;
e[k].value=en[i][j];
k++;
}
}
makeSet();//初始化集合
qsort(e,k,sizeof(struct edge),cmp);//按照边的权值非递减顺序对边进行排序
for(i=0;i<k;i++)
{
x=findSet(e[i].u);//寻找x所在集合的标志点
y=findSet(e[i].v);//寻找y所在集合的标志点
if(x!=y)//x和y不属于同一个集合
{
unionSet(x,y);//进行x和y所在集合的合并操作
sum+=e[i].value;//将该边的权值计入总代价
p[h++]=i;
}
else{}
}
printf("最小生成树的代价为：%d\n",sum);
printf("最小生成树的各边及权值依次为：\n");
for(i=0;i<h;i++)
printf("边%c - %c 权值:%d \n",e[p[i]].u+'a',e[p[i]].v+'a',e[p[i]].value);

return 0;
}

并查集的代码写的很精炼，对我来说一直很难完全明白，需要多看几遍。
感觉并查集这种结构太有用了，一定要掌握！

参考博客：

介绍并查集：http://www.slyar.com/blog/disjoint-set.html

介绍kruskal算法原理及其实现：http://www.cnblogs.com/lpshou/archive/2012/07/02/2573006.html