最小生成树

图的最小生成树算法的实现（Prim算法）

一、实验目的
1．熟悉连通图最小生成树的算法实现。
2．掌握带权图的存储结构和处理方法。

二、实验内容
1、连通图的最小代价生成树成为最小生成树。
2、采用图的邻接矩阵存储结构来存储边上的权值。
3、图中顶点最大数定义为9个，输入顶点个数为9个以内整数。
4、顶点输入格式，如果是三个顶点“A,B,C”。
5、边的输入格式，如AB，AB边上的权重为3，为“A,B,3”。
6、以输入3个顶点3条边为例，从第1个顶点出发生成最小树，并按照发现最小边的先后顺序输出。

三、实验步骤
1、输入顶点数和边数(输入格式为:顶点数,边数)。
2、输入顶点名称(输入格式为:a,b,c…)。
3、输入每条边对应的两个顶点及权重(输入格式为:a,b,权重)。
4、依照“起点，终点，权值”的形式输出最小生成树的各条边。

样例输入：
3,3
A,B,C
A,B,1
A,C,2
B,C,3

样例输出：
A,B,1
A,C,2

---

#include <stdio.h>
#define INFINITY 10000
#define MAXVEX 20    //最大顶点数

typedef struct{
    char adjvex;
    int lowcost;
}closedge[MAXVEX];
 
typedef struct{
    char adjvex[MAXVEX];      //顶点表
    int arcs[MAXVEX][MAXVEX]; //邻接矩阵
    int vexnum, arcnum;       //图的当前点数和边数
}AMGraph;


int LocateVex(AMGraph *G, char x)
{
    int i;
    for(i = 0; i < G->vexnum; i++)
        if(x == G->adjvex[i])
            return i;
    return -1;
} 

void CreateUDN(AMGraph *G)  //采用邻接矩阵表示法创建无向网
{
    int i, j, k, weight;
    char a, b;
         
    printf("Input the vexnum and arcnum:");
    scanf("%d,%d", &G->vexnum, &G->arcnum);
         
    printf("Input the information of vertexes:\n");
    for(i = 0; i < G->vexnum; i++){
        getchar();
        scanf("%c",&(G->adjvex[i]));
    }
         
    for(i = 0; i < G->vexnum; i++)
        for(j = 0; j < G->vexnum; j++)
            G->arcs[i][j] = INFINITY;
     
    printf("Enter the vertices attached to an edge and weight in turn:\n");
    for(k = 0; k < G->arcnum; k++) {
        getchar();
        scanf("%c,%c,%d",&a,&b,&weight);
        i = LocateVex(G, a);
        j = LocateVex(G, b);
        G->arcs[i][j] = weight;
        G->arcs[j][i] = weight;
    }
}

int Minimum(closedge M, AMGraph *G) {
    int i, j, k, min;
    i = 0;
    while(!M[i].lowcost)
        i++;
    min = M[i].lowcost;
    k = i;
    for(j = i + 1; j < G->vexnum; j++)
        if(M[j].lowcost > 0)
            if(min > M[j].lowcost) {
                min = M[j].lowcost;
                k = j;
            }
    return k;
}

void MiniSpanTree_Prim(AMGraph *G, char u)
{
    int i, j, k;
    char a, b;
    closedge L;
    k = LocateVex(G, u);
    for(i = 0; i < G->vexnum; i++)   //初始化辅助数组
    {
        if(i != k) {
            L[i].adjvex = u;
            L[i].lowcost = G->arcs[k][i];
        }
    }
    L[k].lowcost = 0;
 
    printf("The obtained MST is:\n");
    for(i = 1; i < G->vexnum; i++) {
        k = Minimum(L, G);
        a = L[k].adjvex;
        b = G->adjvex[k];
        printf("%c,%c,%d\n", a, b, G->arcs[LocateVex(G, a)][k]);  //输出最小生成树的边
        L[k].lowcost = 0;
        for(j = 0; j < G->vexnum; j++) {
            if(G->arcs[k][j] < L[j].lowcost) {
                L[j].adjvex = G->adjvex[k];
                L[j].lowcost = G->arcs[k][j];
            }
        }
        
    }
}

int main()
{
    AMGraph G;
    CreateUDN(&G);
    MiniSpanTree_Prim(&G, G.adjvex[0]);
    return 0;
}