最小生成树Kruskal算法学习

#include <iostream>

using namespace std;

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
#define MAXCOST 99
typedef struct
{
    int u;     //边的起始顶点
    int v;     //边的终止顶点
    int w;     //边的权值
}Edge;

typedef struct

{
    int vertex[MAXSIZE];
    int edges[MAXSIZE][MAXSIZE];

} MyGraph;

void GrarhPrint(MyGraph*g,int n);
void CreateMGraph(MyGraph*g,int e,int n)
void Bubblesort(Edge R[],int e);
void Kruskal(MyGraph *g,int n);

int main()
{

    MyGraph *g=(MyGraph*)malloc(sizeof(MyGraph));
    CreateMGraph(g,10,6);
    Kruskal(g,6);
    return 0;
}
void CreateMGraph(MyGraph*g,
                  int e,//边数
                  int n //顶点数
                  )

{
    int i,j,k,m;
    printf("Input data of vertex(0~n-1):\n");

    for(i=0; i<n; i++)
    {
        g->vertex[i]=i; //把顶点0~n-1保存的数组中
    }
    //对顶点初始化，该开始都是没有通路
    for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
        {
            if(i==j)
                g->edges[i][j]=0;
            else
                g->edges[i][j]=MAXCOST;//99为不通
        }
    }
    //输入通路，并确定边的权值
    for(k=0; k<e; k++)
    {
        printf("Input edge of(i,j) and edge of size:");
        scanf("%d%d%d",&i,&j,&m);
        g->edges[i][j]=m;
        g->edges[j][i]=m;
    }
    GrarhPrint(g,n);
}
//输出图
void GrarhPrint(MyGraph*g,int n)
{
    int i=0;
    int j=0;
    for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
            if(g->edges[i][j]==MAXCOST||i==j)
                printf("∞\t");
            else
                printf("%d\t",g->edges[i][j]);             
        printf("\n");
    }
}

void Bubblesort(Edge R[],int e)//冒泡排序
{
    Edge temp;
    int i,j,swap;
    for(i=0;i<e-1;i++)
    {
        swap=0;
        for(j=0;j<e-i-1;++j)
        {
            if(R[j].w>R[j+1].w)
            {
                temp=R[j];
                R[j]=R[j+1];
                R[j+1]=temp;
                swap=1;
            }
        }
        if(swap==0)
            break;
    }
}
void Kruskal(MyGraph *g,int n)
{
    int i,j,u1,v1,sn1,sn2,k;
    int vest[MAXSIZE];
    Edge R[MAXSIZE];
    k=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(i<j && g->edges[i][j]!=MAXCOST)
            {
                R[k].u=i;
                R[k].v=j;
                R[k].w=g->edges[i][j];
                k++;
            }
        }
    }
    Bubblesort(R,k);
    for(i=0;i<n;i++)
        vest[i]=i;
    k=1;
    j=0;
    while(k<n)
    {
        u1=R[j].u;
        v1=R[j].v;
        sn1=vest[u1];
        sn2=vest[v1];
        if(sn1!=sn2)
        {
            printf("Edge:(%d,%d),Wight:%d\n",u1,v1,R[j].w);
            k++;
            for(i=0;i<n;i++)
            {
                if(vest[i]==sn2)
                    vest[i]=sn1;
            }
        }
        j++;
    }
}

Kruskal算法，我感觉就是把图的每一条边的信息保存到数组中，然后按照边的权值从小到大排好序，接着每次从这个数组中按照顺序选一条边，然后把这条边的两个顶点置为一组，例如：第一次选的是顶点0、2，所以把他俩归为一组，可以把2置为0，下次找到顶点1、4，把顶点4置为1；接着找到顶点1，2；可以把顶点1、4置为0；在Kruskal函数中数组vest就是这个作用，刚开始各个顶点的分组都不相同，根据边的信息来调整。