【C语言数据结构】最小生成树Kruskal（克鲁斯卡尔）算法 | 原理和代码

一、代码

方法一：优化图的存储结构

#include <stdio.h>
#include <stdlib.h>
#define maxe 100
#define maxv 20

typedef struct
{
    int from,to;
    int weight;
}EdgeType;

typedef struct  //优化的图结构
{
    char vertex[maxv];    //存放数据内容
    EdgeType edges[maxe];   //边
    int vnum,edgenum;
}EdgeGraph;

int partitions(EdgeType *a,int first,int end);  //函数声明
void quickSort(EdgeType r[],int first,int end);

void creatMGraph(EdgeGraph *G)
{
    int i,j,k,w;
    printf("输入顶点数和边数\n");
    scanf("%d %d",&G->vnum,&G->edgenum);
                                        //vex赋值省略
    for( k=0;k<G->edgenum;k++)
    {
        printf("输入边(vi,vj)的下标i j以及权重w，用逗号隔开\n");
        scanf("%d %d %d",&i,&j,&w);
        G->edges[k].from=i;
        G->edges[k].to=j;
        G->edges[k].weight=w;
    }

    quickSort(G->edges,0,G->edgenum-1);

}

//快速排序
void quickSort(EdgeType r[],int first,int end)
{
    int pos;
    if(first<end)
    {
        pos=partitions(r,first,end);
        quickSort(r,first,pos-1);
        quickSort(r,pos+1,end);
    }
}

int partitions(EdgeType *a,int first,int end)
{
    int i,j;
    EdgeType t;
    i=first; j=end;
    while(i<j)
    {
        while(i<j && a[i].weight<=a[j].weight)
            j--;
        if(i<j)
        {
            t=a[i]; a[i]=a[j];a[j]=t;
            i++;
        }

        while(i<j &&a[i].weight<=a[j].weight)
            i++;
        if(i<j)
        {
            t=a[i]; a[i]=a[j];a[j]=t;
            j--;
        }
    }

    return i;
}

int findroot(int parent[],int v)
{
    int t=v;
    while(parent[t]>0)
        t=parent[t];
    return t;
}
void Kruskal_MST(EdgeGraph G)
{
    int parent[maxv];
    int i,numm,v1,v2;
    for(i=0;i<G.vnum;i++)  //每个点为树的根节点
        parent[i]=-1;

    for(i=0,numm=0;i<G.edgenum;i++)
    {
        v1=findroot(parent,G.edges[i].from);
        v2=findroot(parent,G.edges[i].to);
        if(v1!=v2)   //跟结点不同
        {
            printf("(%d,%d) %d\n",G.edges[i].from,G.edges[i].to,G.edges[i].weight);
            parent[v2]=v1; //两个点合成树
            numm++;   //numm记录边的数，边达到n-1时可以提前结束循环（算法改进）
            if(numm==G.vnum-1)
                return;
        }
    }


}

int main()
{
    EdgeGraph g;
    creatMGraph(&g);
    Kruskal_MST(g);
    return 0;
}

方法二：参考大话数据结构，结构体不同

typedef struct
{
    char vex;
    int arc[maxvex][maxvex];
    int numvex,numedge;
}MGraph;

typedef struct
{
	int begin,end,weight;
}Edge;
// 在函数Kruskal里定义，其他的都一样
Edge edges[maxe];
int parent[maxv];

结果

二、原理

1、两个最小生成树算法的对比

• Prim是对点做操作，形成在最小生成树中的点的顶点集U，以及一个待处理点的顶点集V-U,每次找出连接这两个集合的最短边，构成最小生成树，并将顶点加入集合U，直到所有顶点都处理完毕。
• Kruskal是对边做操作，对边进行排序，每次选出一条最短边。如果它和当前最小生成树不构成回路，就将其加入最小生成树，否则将其删除，直到所有边都处理完毕。

2、Kruskal算法的思路

• 对边存储 ：存储边不用临阶矩阵，改用带有 起点、终点、权值的结构体数组
• 排序算法：采用快速排序 、插入排序等都可以
• 对边的权重排序，把最小的边的两个点连一起，确保不形成环，从小到大尝试每条边（生成n-1条边）。
• 确保不形成环：把每个点连接看成树，保证连接2个点所在的树根节点不同就行 ，用parent[ maxv] 存储根节点。

3、时间复杂度 ：O（eloge） e为边数
注意：通过parent数组画不出生成树来。