Kruskal算法构造最小生成树

Kruskal算法来构造最小生成树，我总结了分为以下步骤：

（1）建图，构造Kruskal边集，边集元素应该包括该边的起始顶点、终止顶点、权值；

（2）将边集按权值从小到大的顺序进行排序；

（3）从小到大依次从Kruskal边集中取边加入最小生成树集合，判断条件：将该边加入最小生成树集合，与生成树集合中原有的边不构成环；

（4）最小生成树集合中元素（构成生成树的边）的个数为原图顶点数-1时，代表最小生成树构造完毕。

Kruskal核心伪代码如下：

Kruskal(MGragh *Gra)
{
    对Kruskal边集按权值从小到大排序

    for (边集)
    {
        // 判断边集中的边能否加入最小生成树集合

        n=该边的起始顶点所能到达的最新顶点
        m=该边的终止顶点所能到达的最新顶点

        如果n等于m 说明该边能够成环路，所以不能加入最小生成树集合

        如果n不等于m 说明该边可以加入最小生成树集合
        {
            更新：n能够到达m
        }
    }
}

实例：

源代码：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #define MAX_VERTEX_NUM 100
 #define MAX_EDGE_NUM 200
 #define MAX_VERTEX_NAMELEN 100

 typedef struct{
     char name[MAX_VERTEX_NAMELEN];
 }VerType;

 // 图的邻接矩阵存储结构
 typedef struct{
     int VertexNum,EdgeNum;                        // 顶点数，边数
     VerType Vertex[MAX_VERTEX_NUM];               // 顶点集
     int Edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];     // 边集
 }MGragh;

 // 克鲁斯卡尔边集
 typedef struct{
     int b;        // 起始顶点
     int e;        // 终结顶点
     int w;        // 权值
 }KruskalEdge;
 KruskalEdge edge[MAX_EDGE_NUM];

 // 快速排序cmp
 int cmp(const void *a, const void *b)
 {
     KruskalEdge *c = (KruskalEdge *)a;
     KruskalEdge *d = (KruskalEdge *)b;

     // 权值从小到大排序 权值相同则按起始顶点从小到大排序
     if (c->w != d->w){
         return c->w - d->w;
     }
     else{
         return c->b - d->b;
     }
 }

 // 邻接矩阵建图及建立克鲁斯卡尔边集
 void CreateMGragh(MGragh *Gra)
 {
     int i,j,k,w;
     char v1[MAX_VERTEX_NAMELEN],v2[MAX_VERTEX_NAMELEN];

     printf("请输入顶点数及边数(顶点数 边数)\n");
     scanf("%d %d%*c",&(Gra->VertexNum),&(Gra->EdgeNum));

     printf("请输入顶点信息\n");
     for (i=; i<Gra->VertexNum; i++){
         printf("%d.",i+);
         gets(Gra->Vertex[i].name);
     }

     // 初始化邻接矩阵
     for (i=; i<Gra->VertexNum; i++){
         for (j=; j<Gra->VertexNum; j++){
             Gra->Edge[i][j] = ;
         }
     }
     printf("请输入边信息(顶点，顶点，权值)\n");
     for (i=; i<Gra->EdgeNum; i++){
         printf("%d.",i+);
         scanf("%[^,]%*c%[^,]%*c%d%*c",v1,v2,&w);

         for (j=; j<Gra->VertexNum; j++){
             for (k=; k<Gra->VertexNum; k++){
                 if (strcmp(Gra->Vertex[j].name,v1) ==  && strcmp(Gra->Vertex[k].name,v2) == ){
                     Gra->Edge[j][k] = Gra->Edge[k][j] = w;

                     // 构造克鲁斯卡尔边集 使起始顶点<终止顶点
                     if (j<k){
                         edge[i].b = j;
                         edge[i].e = k;
                         edge[i].w = w;
                     }
                     else{
                         edge[i].b = k;
                         edge[i].e = j;
                         edge[i].w = w;
                     }
                 }
             }
         }
     }

     // 将克鲁斯卡尔边集按权值从小到大排序
     qsort(edge,Gra->EdgeNum,sizeof(edge[]),cmp);
 }

 // 找到顶点t所能到达的在时间顺序上最新的点
 // 例如p[0]=6 代表第0个点能够到达第6个点
 int FindLastArrived(int *p, int t)
 {
     while (p[t] > ){
         t = p[t];
     }
     return t;
 }

 // 克鲁斯卡尔算法构造最小生成树
 void MiniTreeByKruskal(MGragh *Gra)
 {
     int i,n,m;
     int p[MAX_VERTEX_NUM];

     // 初始化辅助数组
     for (i=; i<Gra->VertexNum; i++){
         p[i] = ;
     }

     printf("\nKruskal算法构造最小生成树为:\n");
     for (i=; i<Gra->EdgeNum; i++){
         n = FindLastArrived(p,edge[i].b);
         m = FindLastArrived(p,edge[i].e);
         if (n != m){    // 如果n==m 说明存在环路
             p[n] = m;    // 将边加入生成树，并令n能到达m
             printf("(%s --> %s) %d\n",Gra->Vertex[edge[i].b].name,Gra->Vertex[edge[i].e].name,edge[i].w);
         }
     }
 }

 int main()
 {
     MGragh g;
     CreateMGragh(&g);
     MiniTreeByKruskal(&g);
     return ;
 }

测试用例及结果：