算法导论-用于不想交集合的数据结构（并查集）-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[n];//father[x]表示x的父节点；
int rank[n];//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[n][n]={
            {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