最小生成树之Prim算法（最原始最详细入门）

//算法6.8　普里姆算法
#include <iostream>
using namespace std;

typedef char VerTexType;
typedef int ArcType;
#define MVNum 100
#define MaxInt 32767                        //表示极大值，即∞

//辅助数组的定义，用来记录从顶点集U到V-U的权值最小的边
struct{
    VerTexType adjvex;                        //最小边在U中的那个顶点
    ArcType lowcost;                        //最小边上的权值
}closedge[MVNum];

//- - - - -图的邻接表存储表示- - - - -
typedef char VerTexType;                      //假设顶点的数据类型为字符型
typedef int ArcType;                          //假设边的权值类型为整型
typedef struct{
    VerTexType vexs[MVNum];                    //顶点表，一维数组
    ArcType arcs[MVNum][MVNum];              //邻接矩阵，表示i-j边上的权值
    int vexnum,arcnum;                        //图的当前顶点数和边数
}AMGraph;

int mincost;         //mincost表示最小生成树所有路径之和的最小值
bool vis[MVNum];    //标记已经归纳到集合U中
int LocateVex(AMGraph G , VerTexType v){
    //确定点v在G中的位置，即在顶点数组vexs中查找顶点v的下标
    for(int i = 0; i < G.vexnum; ++i)
        if(G.vexs[i] == v)
            return i;
        return -1;//找不到就返回-1
}//LocateVex

void CreateUDN(AMGraph &G){
    //采用邻接矩阵表示法，创建无向网G
    int i , j , k;
    cout <<"请输入总顶点数，总边数，以空格隔开:";
    cin >> G.vexnum >> G.arcnum;                    //输入总顶点数，总边数
    cout << endl;

    cout << "输入点的名称，如a或1" << endl;

    for(i = 0; i < G.vexnum; ++i){
        cout << "请输入第" << (i+1) << "个点的名称:";
        cin >> G.vexs[i];                         //依次输入点的信息
    }
    cout << endl;
    for(i = 0; i < G.vexnum; ++i)             //初始化邻接矩阵，边的权值均置为极大值MaxInt
        for(j = 0; j < G.vexnum; ++j)
            G.arcs[i][j] = MaxInt;
    cout << "输入边依附的顶点及权值，如a b 5" << endl;
    for(k = 0; k < G.arcnum;++k){                     //构造邻接矩阵
        VerTexType v1 , v2;
        ArcType w;
        cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
        cin >> v1 >> v2 >> w;                     //输入一条边依附的顶点及权值
        i = LocateVex(G, v1);  j = LocateVex(G, v2);  //确定v1和v2在G中的位置，即顶点数组的下标
        G.arcs[i][j] = w;                       //边<v1, v2>的权值置为w
        G.arcs[j][i] = G.arcs[i][j];    //置<v1, v2>的对称边<v2, v1>的权值为w
    }//for
}//CreateUDN

int Min(AMGraph G){
    //返回权值最小的点
    int index = -1;
    int mina = MaxInt;
    for(int i = 0 ; i < G.vexnum ; ++i){
        if(!vis[i] && mina > closedge[i].lowcost ){//在剩下的集合V-U中选择距离U集合最近的顶点，即权值最小
            mina = closedge[i].lowcost;
            index = i;
        }
    }//for
    return index;//返回该下标
}//Min

void MiniSpanTree_Prim(AMGraph G, VerTexType u){//加点法
    //无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T，输出T的各条边
    int k , j , i;
    mincost = 0;
    VerTexType u0 , v0;
    k =LocateVex(G, u);            //k为顶点u的下标
    for(j = 0; j < G.vexnum; ++j){   //对V-U的每一个顶点vi，初始化closedge[i]
        if(j != k){
            vis[j]=false;
            closedge[j].adjvex = u; //默认除u外的各个顶点到U集合中的顶点u的权值最小
            closedge[j].lowcost = G.arcs[k][j];  //{adjvex, lowcost}
        }//if
    }//for
    vis[k]=true;closedge[k].lowcost=0; //初始，U = {u},标记u已经归纳到集合中，自己到自己的权值为0
    for(i = 1; i < G.vexnum; ++i){    //选择其余n-1个顶点，生成n-1条边(n= G.vexnum)
        k = Min(G);
        if(k==-1)break;               //k如果是-1，表示最小生成树已经建立
        //求出T的下一个结点：第k个顶点，closedge[k]中存有当前最小边
        u0 = closedge[k].adjvex;        //u0为最小边的一个顶点，u0∈U
        v0 = G.vexs[k];              //v0为最小边的另一个顶点，v0∈V-U
        cout << "边  " <<u0 << "--->" << v0 << "   权值为" << closedge[k].lowcost << endl;//输出当前的最小边(u0, v0)及其权值
        vis[k]=true;mincost+=closedge[k].lowcost; //第k个顶点并入U集,标记此时顶点k已经归纳到集合U中
        for(j = 0; j < G.vexnum; ++j)
            if(!vis[j] && G.arcs[k][j] < closedge[j].lowcost){//新顶点并入U后在V-U中重新选择最小边
                closedge[j].adjvex = G.vexs[k];  //表示顶点j到顶点k还有比原来j到集合U中有最小权值
                closedge[j].lowcost = G.arcs[k][j];
            }//if
    }//for
}//MiniSpanTree_Prim

int main(){
    cout << "************算法6.8　普里姆算法**************" << endl << endl;
    AMGraph G;
    CreateUDN(G);
    cout << endl;
    cout << "无向图G创建完成！" << endl;
    cout <<endl;

    cout << "******利用普里姆算法构造最小生成树结果：******" << endl;
    MiniSpanTree_Prim(G , G.vexs[0]);//传入起始的顶点
    cout <<endl;
    cout<<"最小生成树的所有路径之和最小值为"<<mincost<<endl;
    return 0;
}//main