最小生成树 prim与kruskal算法实现C、C++

一、Prim

#include <cstdio>
#include <algorithm>
#define Max 100
#define Maxint 1000000
using namespace std;
typedef struct
{
    int vex,arc;
    int m[Max][Max];
}Graph;
typedef struct
{
    int from;
    int lowcost;
}shortEdge;
int  mincost=0;
void CreatGraph(Graph &G)
{
    int i,j,k;
    printf("请输入顶点数和边数:");
    scanf("%d%d",&G.vex,&G.arc);
    for(i=0;i<G.vex;i++)
    {
        for(j=0;j<G.vex;j++)
        {
            if(i!=j) G.m[i][j]=Maxint;
            else G.m[i][j]=0;
        }
    }
    for(i=0;i<G.arc;i++)
    {
        int e1,e2,weight;
        printf("第%d条边的顶点->顶点->权值:",i+1);
        scanf("%d%d%d",&e1,&e2,&weight);
        G.m[e1][e2]=weight;
        G.m[e2][e1]=weight;
    }
}
void output(shortEdge K[],int k)
{
    printf("%d-->%d cost:%d\n",K[k].from,k,K[k].lowcost);
    mincost=mincost+K[k].lowcost;
}
int minEdge(shortEdge K[],int n)
{
    int min=Maxint;
    int flag=-1;
    for(int i=0;i<n;i++)
    {
        if(K[i].lowcost<min&&K[i].lowcost)
        {
            min=K[i].lowcost;
            flag=i;
        }
    }
    return flag;
}
void Prim(Graph G,shortEdge K[],int start)
{
    int i,j,k;
    for(i=0;i<G.vex;i++)
    {
        K[i].from=start;
        K[i].lowcost=G.m[start][i];
    }
    K[start].lowcost=0;
    for(i=0;i<G.vex-1;i++)
    {
        k=minEdge(K,G.vex);
        output(K,k);
        K[k].lowcost=0;
        for(j=0;j<G.vex;j++)
        {
            if(G.m[k][j]<K[j].lowcost&&k!=j)
            {
                K[j].lowcost=G.m[k][j];
                K[j].from=k;
            }
        }
    }
}
int main()
{
    Graph G;
    shortEdge K[Max];
    CreatGraph(G);
    int start;
    printf("请输入起点:");
    scanf("%d",&start);
    Prim(G,K,start);
    //printf("%13d",mincost);
    return 0;
}

二、Kruskal

#include <cstdio>
#include <algorithm>
#define Max 100
#define Maxint 1000000
using namespace std;
typedef struct
{
    int vex;
    int arc;
    int m[Max][Max];
}Graph;
typedef struct
{
    int from;
    int to;
    int weight;
}shortEdge;
void CreatGraph(Graph &G)
{
    int i,j;
    printf("请输入顶点数和边数:");
    scanf("%d%d",&G.vex,&G.arc);
    for(i=0;i<G.vex;i++)
    {
        for(j=0;j<G.vex;j++)
        {
            if(i==j) G.m[i][j]=0;
            else G.m[i][j]=Maxint;
        }
    }
    for(i=0;i<G.arc;i++)
    {
        int e1,e2,weight;
        printf("第%d条边的顶点->顶点->权值:",i+1);
        scanf("%d%d%d",&e1,&e2,&weight);
        G.m[e1][e2]=weight;
        G.m[e2][e1]=weight;
    }
}
bool cmp(shortEdge a1,shortEdge a2)
{
    return a1.weight<a2.weight;
}
int findroot(int parent[],int v)
{
    int t=v;
    while(parent[t]>-1) t=parent[t];
    return t;
}
void outputMST(shortEdge a)
{
    printf("%d->%d weight:%d\n",a.from,a.to,a.weight);
}
void Kruskal(Graph G,int parent[],shortEdge sE[])
{
    int i,j,k=0;
    int vex1,vex2;
    for(i=0;i<Max;i++) parent[i]=-1;
    int e=G.vex;
    for(i=0;i<e;i++)
    {
        for(j=i+1;j<e;j++)
        {
            if(G.m[i][j]!=Maxint)
            {
                sE[k].from=i;
                sE[k].to=j;
                sE[k].weight=G.m[i][j];
                k++;
            }
        }
    }
    sort(sE,sE+k,cmp);
    int num=0;
    for(i=0;i<k;i++)
    {
        vex1=findroot(parent,sE[i].from);
        vex2=findroot(parent,sE[i].to);
        if(vex1!=vex2)
        {
            outputMST(sE[i]);
            parent[vex2]=vex1;
            num++;
            if(num+1==G.vex) return;
        }
    }
}
int main()
{
    Graph G;
    CreatGraph(G);
    int parent[Max];
    shortEdge sE[Max];
    Kruskal(G,parent,sE);
    return 0;
}