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("请输入顶点数及边数(顶点数 边数)
");
    scanf("%d %d%*c",&(Gra->VertexNum),&(Gra->EdgeNum));
    
    printf("请输入顶点信息
");
    for (i=0; i<Gra->VertexNum; i++){
        printf("%d.",i+1);
        gets(Gra->Vertex[i].name);
    }
    
    // 初始化邻接矩阵
    for (i=0; i<Gra->VertexNum; i++){
        for (j=0; j<Gra->VertexNum; j++){
            Gra->Edge[i][j] = 0;
        }
    }
    printf("请输入边信息(顶点，顶点，权值)
");
    for (i=0; i<Gra->EdgeNum; i++){
        printf("%d.",i+1);
        scanf("%[^,]%*c%[^,]%*c%d%*c",v1,v2,&w);

        for (j=0; j<Gra->VertexNum; j++){
            for (k=0; k<Gra->VertexNum; k++){
                if (strcmp(Gra->Vertex[j].name,v1) == 0 && strcmp(Gra->Vertex[k].name,v2) == 0){
                    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[0]),cmp);
}

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

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

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

    printf("
Kruskal算法构造最小生成树为:
");
    for (i=0; 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
",Gra->Vertex[edge[i].b].name,Gra->Vertex[edge[i].e].name,edge[i].w);
        }
    }
}

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

测试用例及结果：