Kruskal算法

        图的Kruskal算法思想比较简单，每次找出候选边中权值最小的边，将该边并入生成树中，重复此过程直到所有的边都被检测完为止。

       将图中按照权值从小到大排序，然后从最小边开始扫描各边，并检测当前边是否为候选边，即是否该边的并入会产生回路回路，如不构成回路，则将该边并入当前生成树中，知道所有边斗被检测万为止。判断是否产生回路要用到并查集。并查集的概念在此就不赘述了，大家可以google。代码如下：

#ifndef MGRAPH_1_H_
#define MGRAPH_1_H_

#define INF 9999
#define maxSize 30
typedef int VertexType;    
typedef struct 
{
    int edges[maxSize][maxSize];
    int n,e;
    VertexType vex[maxSize];
}MGraph;

typedef struct 
{
    int a;
    int b;
    int w;
}Road;

Road road[maxSize];

void CreateMGraph( MGraph * G)
{
    int i,j,k,weight;
    int n1,n2;
    
    printf("请输入顶点数和边数（输入格式为：顶点数，边数）：\n");
    scanf("%d,%d",&(G->n),&(G->e));
    //给顶点编号
    for(i=0;i<G->n;i++)
        G->vex[i]=i;
    for(i=0;i<G->n;i++)
        for(j=0;j<G->n;j++)
            G->edges[i][j]=INF;
    
    printf("请输入对应的边的结点号和边的权值(i,j,w)\n");
    for(k=0;k<G->e;k++)
    {
        printf("第%d条边的结点号和权值：",k+1);
        scanf("%d,%d,%d",&i,&j,&weight);
        G->edges[i][j]=weight;
        G->edges[j][i]=weight;
        road[k].a=i;
        road[k].b=j;
        road[k].w=weight;
    }
}
#endif
//头文件结束
#include<stdio.h>
#include<stdlib.h>
#include"MGraph_1.h"


int v[maxSize];
int getroot(int a)
{
    while(a!=v[a])a=v[a];
    return a;
}

int cmp(const void *a,const void * b)
{
    Road *aa=(Road * )a;
    Road *bb=(Road * )b;
    return (aa->w>bb->w);
}
void Kruskal (const MGraph G,int * sum)
{
    int i;
    int N,E,a,b;
    N=G.n;
    E=G.e;
    *sum=0;
    for(i=0;i<N;i++)v[i]=i;//初始化并查集数组
    qsort(road,E,sizeof(Road),cmp);
    for(i=0;i<E;i++)
    {
        a=getroot(road[i].a);
        b=getroot(road[i].b);
        if(a!=b)
        {
            v[a]=b;
            *sum  =*sum+road[i].w;
            printf("(%d,%d)\n",road[i].a,road[i].b);
        }
    }
}

void main(void)
{
    MGraph G;
    int sum,i;
    CreateMGraph(&G);
    Kruskal(G,&sum);
    for(i=0;i<G.n;i++)
        printf("%d ",v[i]);
    printf("\n%d",sum);
}