用父亲结点数组实现并查集

#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
typedef struct ufset *UFset;
struct ufset
{
    int parent[100001];
    int root[100001];
}UFS;
int s[100001],y[100001],d[10000],add;
int UFfind(int e,UFset U)
{
    int i,j=e;
    while(U->root[j]==0)
    {
        j=U->parent[j];
    }
    while(j!=e)
    {
        i=U->parent[e];
        U->parent[e]=j;
        e=i;
    }
    return j;
}
int UFunion(int i,int j,UFset U)
{
        U->parent[j]+=U->parent[i];
        U->root[i]=0;
        U->parent[i]=j;
        return j;
}
int main()
{
    UFset UF;
    UF=(UFset)malloc(sizeof(UFS));
    int e,n,m,k,x,i,a,b,t1,t2;
    scanf("%d %d",&n,&m);
    for(e=1;e<=n+1;e++)
    {
        UF->parent[e]=1;
        UF->root[e]=1;
    }
    for(i=0;i<m;i++)
    {
        scanf("%d %d",&a,&b);
        t1=UFfind(a,UF);t2=UFfind(b,UF);
        if(t1!=t2)
        {
            UFunion(t1,t2,UF);
        }
    }
    int t=0; 
    for(i=1;i<n+1;i++)
    {
        if(UF->root[i]==1)
        {
            s[t]=UF->parent[i];
            y[t++]=i;
        }        
    }
    sort(s,s+t);
    add=k=0;
    for(i=1;;i++)
    {
        if(add>=n)
            break;
        else
        {
            add+=s[t-i];
            d[k++]=UFfind(y[t-i],UF);
        }
    }
    printf("%d
",k);
    sort(d,d+k);
    for(i=0;i<k;i++)
    {
        if(i<k-1)
        printf("%d ",d[i]);
        else
            printf("%d
",d[i]);
    }
    return 0;
}

 并查集结构简单。在数据结构作业大招秒杀和战争来了中有巧妙的运用

在下面所描述的改进的并查集结构中增加一个根节点数组root，用来记录树的根结点。
当元素e所在结点不是根节点时，root[e]=0,parent[e]=表示其父节点；当元素e所在结点是根节点
时，root[e]=1,parent[e]的值是树中结点的个数.

typedef struct ufset *UFset;
struct ufset
{
    int parent[100];
    int root[100];
}UFS;

UFfind(e.U)运算从元素e相应的结点走到树根处，找出所在集合的元素
加速并查集运算的另一的办法就是采用路径压缩技术，在执行UFfind时，实际是找到了从一个结点
到树根的一条路径。路径压缩技术就是把这条路上的所有结点都改为树根的儿子，实现路径压缩的最简单方法是
在这条路上走两次，第一次找到树根，第二次将路上所有结点的父节点都改为树根。

int UFfind(int e,UFset U)
{
    int i,j=e;
    while(U->root[j]==0)
    {
        j=U->parent[j];
    }
    while(j!=e)
    {
        i=U->parent[e];
        U->parent[e]=j;
        e=i;
    }
    return j;
}

在最坏情况下，合并可能使n个结点的数退化成一条链，在这种情下，对所有元素各执行
一次UFfind将耗时O(N*N) 。所以，尽管，UFunion只需要O(1)时间，当UFfind可能是总时间
耗费很大，为了克服这个缺点。可以做以下改进，使得每次UFind不超过O(longn)时间。在树
根中保存该树的结点数，每次合并时，总将小树合并到大树上。当一个结点从一棵树移到另
一颗数上时，这个节点到树根的距离就增加1，而这个节点所在的树的大小至少增加一倍。
于是并查集中每一个结点至多被移动O(longn)次，从而每个节点到树根的距离不会超过O(longn)。
所以每次UFfind运算只需要O(longn)时间。

int UFunion(int i,int j,UFset U)
{
    if(U->parent[i]<U->parent[j])
    {
        U->parent[j]+=U->parent[i];
        U->root[i]=0;
        U->parent[i]=j;
        return j;
    }
    else
    {
        U->parent[j]+=U->parent[i];
        U->root[j]=0;
        U->parent[j]=i;
        return i;
    }
}