数据结构——kruskal算法——最小生成树

首先应该理解kruskal算法思想：在连通图N=(V,{E})上，先建立一个初始状态为包含n个顶点而无边的非连通分图T=（V，{}），在边集E中找到权值最小的边，若此边的两个顶点落在T的不同的连通分量上，则将边加入T中，否则舍弃它而选择下一条代价小的边。以此类推，直到所有的顶点都落在同一连通分量上即可。

给出源码：

#include"iostream"
using namespace std;

#define MAX 1000

typedef struct ArcCell
{
    double adj;
    int *info;
}ArcCell,adjmatrix[100][100];//adj表示边的权值大小

typedef struct 
{
    char vexs[100];
    adjmatrix arcs;
    int vexnum,arcnum;//图的顶点个数和弧度数
}MGraph;//以上均为用邻矩阵的储存结构定义图

typedef struct Node
{//建立一个储存两个顶点和它们之间权值大小的结构体
    char start;
    char end;
    double value;
}Node,Dgevalue[100];

int locatevex(MGraph G,char ch)
{//定位起始顶点ch在图中的位置
    int k;
    for(int i=0;i<G.vexnum;i++)
    {
        if(G.vexs[i]==ch)
            k=i;
    }
    return k;
}

int creatmatrix(MGraph &G,Dgevalue &dgevalue)
{//构造邻接矩阵
    int i,j,k;
    cout<<"请输入顶点个数和弧度数"<<endl;
    cin>>G.vexnum>>G.arcnum;
    
    for(i=0;i<G.vexnum;i++)//读入顶点
        cin>>G.vexs[i];

    for(i=0;i<G.vexnum;i++)
    {//初始化边的权值为MAX
        for(j=0;j<G.vexnum;j++)
        {
            G.arcs[i][j].adj=MAX;
        }
    }
    cout<<"请输入一条边两端的定点及其上权值"<<endl;
    for(k=0;k<G.arcnum;k++)
    {//读入始终点及其上的权值value
        cin>>dgevalue[k].start>>dgevalue[k].end>>dgevalue[k].value;
        i=locatevex(G,dgevalue[k].start);
        j=locatevex(G,dgevalue[k].end);
        G.arcs[i][j].adj=dgevalue[k].value;
        G.arcs[j][i].adj=G.arcs[i][j].adj;
    }
    return 0;
}

void sort(MGraph G,Dgevalue &dgevalue)
{//排序函数
    char p1,p2;
    int i,j,temp;
    for(i=0;i<G.arcnum;i++)
    {//快速排序
        for(j=i;j<G.arcnum;j++)
        {
            if(dgevalue[i].value>dgevalue[j].value)
            {
                temp=dgevalue[i].value;
                dgevalue[i].value=dgevalue[j].value;
                dgevalue[j].value=temp;

                p1=dgevalue[i].start;
                dgevalue[i].start=dgevalue[j].start;
                dgevalue[j].start=p1;

                p2=dgevalue[i].end;
                dgevalue[i].end=dgevalue[j].end;
                dgevalue[j].end=p2;
            }
        }
    }
}

void creatminitree_kruskal(MGraph G,Dgevalue &dgevalue)
{//kruskal 算法
    int i,j,p[100];
    char pa,pb;
    for(i=0;i<G.vexnum;i++)
             p[i]=i;

    sort(G,dgevalue);
    cout<<endl;
    for(i=0;i<G.arcnum;i++)
    {
        pa=p[locatevex(G,dgevalue[i].start)];
        pb=p[locatevex(G,dgevalue[i].end)];

        if(pa!=pb)
        {    //如果a、b不在同一连通分量中
            cout<<dgevalue[i].start<<" "<<dgevalue[i].end<<" "<<dgevalue[i].value<<endl;

        for(j=0;j<G.vexnum;j++)
         {//让a、b位于同一连通分量中
            if(p[j]==pb)
                p[j]=pa;
        
         }
        }
    }
}

int main()
{
    char u;
     MGraph G;
     Dgevalue dgevalue;
     creatmatrix(G,dgevalue);
      cout<<"用kruskal算法求最小生成树";
      creatminitree_kruskal(G,dgevalue);

     return 0;
}