最小生成树--Kruskal算法

与Prim算法不同，Kruskal算法基于并查集和贪心算法，利用并查集判断其是否存在循环。

Kruskal算法基本思想： 对所有边进行排序，优先选取权重小的边，并同时判断其是否联通（利用并查集判断）
数据结构：结构体数组
算法思想：快排，贪心，递归

用结构体来储存边

typedef struct edge{
int u;//顶点
int v;//末点
int w;//权重
}EDGE;
EDGE e[100];

利用快排排序：

void sort(int left,int right)
{
int i,j;
EDGE t;
if(left>right)
return ;
i=left;
j=right;
while(i!=j)
{
while(e[j].w>=e[left].w&&i<j)   j--;
while(e[i].w<=e[left].w&&i<j)   i++;
if(i<j)
{
t=e[i];
e[i]=e[j];
e[j]=t;
}
}

t=e[i];
e[i]=e[left];
e[left]=t;

sort(left,i-1);
sort(i+1,right);
return ;
}

利用并查集来判断是否是形成联通环：

int merge(int x,int y)
{
int i=getf(x);
int j=getf(y);
if(i!=j)//如果不相同则利用偏左原则
{
f[j]=i;//把祖宗更变
return 1;
}
else
return 0;
}
int getf(int v)//利用递归找祖先
{
if(v==f[v])
return v;
else
{
f[v]=getf(f[v]);
return f[v];
}
}

最后利用贪心把边一条条符合条件的边放入集合中：

for(i=1;i<=m;i++)
{
if(merge(e[i].u,e[i].v))
{
sum+=e[i].w;//如果不在一个集合中，则把边放入
count++;//计数器
}
if(count==n-1)
break;
}

来看全部代码的实现：

#include<stdio.h>
#include<string.h>
#include<conio.h>
int f[100];
int n,m,sum,count;
typedef struct edge{
int u;//顶点
int v;//末点
int w;//权重
}EDGE;
EDGE e[100];

int getf(int v);
void sort(int left,int right);
int merge(int x,int y);
int main()
{
int i,j;
scanf("%d %d",&n,&m);
for(i=1;i<=n;i++)   f[i]=i;//初始化并查集
for(i=1;i<=m;i++)
scanf("%d %d %d",&e[i].u,&e[i].v,&e[i].w);
sort(1,m);
for(i=1;i<=m;i++)
{
if(merge(e[i].u,e[i].v))
{
sum+=e[i].w;//如果不在一个集合中，则把边放入
count++;//计数器
}
if(count==n-1)
break;
}
printf("%d",sum);
return 0;
}

void sort(int left,int right)
{
int i,j;
EDGE t;
if(left>right)
return ;
i=left;
j=right;
while(i!=j)
{
while(e[j].w>=e[left].w&&i<j)   j--;
while(e[i].w<=e[left].w&&i<j)   i++;
if(i<j)
{
t=e[i];
e[i]=e[j];
e[j]=t;
}
}

t=e[i];
e[i]=e[left];
e[left]=t;

sort(left,i-1);
sort(i+1,right);
return ;
}
int merge(int x,int y)
{
int i=getf(x);
int j=getf(y);
if(i!=j)//如果不相同则利用偏左原则
{
f[j]=i;//把祖宗更变
return 1;
}
else
return 0;
}
int getf(int v)//利用递归找祖先
{
if(v==f[v])
return v;
else
{
f[v]=getf(f[v]);
return f[v];
}
}

其实这个算法和prim算法中，都包含了贪心算法的思想，只是实现的方式不同。