数据结构之最小生成树(普里姆算法)

1）普里姆算法

可取图中任意一个顶点v作为生成树的根，之后若要往生成树上添加顶点w，则在顶点v和顶点w之间必定存在一条边，并且

该边的权值在所有连通顶点v和w之间的边中取值最小。一般情况下，假设n个顶点分成两个集合：U（包含已落在生成树上

的结点）和V-U（尚未落在生成树上的顶点），则在所有连通U中顶点和V-U中顶点的边中选取权值最小的边。

例如：起始生成树上面就一个顶点。为了连通两个集合，在可选的边中，选择权值最小的。需要辅助数组，V-U中所有顶点。

具体实例如下图所示：求下图的最小生成树 

我们以a点为起始点，此时的U集合={a}，V-U到U集合的路径有a-b=4,a-c=2,取最小的a-c，所以将c点添加到U集合中，U={a,c}。

此时，V-U到U集合的路径有b-a=4,b-c=3,取最小，更新b点到U集合的最短路径为3，此外还有c-d=5,c-h=5,所以，取V-U到Ｕ集

合的最小值为b-c=3，将b点添加到U集合中。U={a,c,b}。此时V-U到U集合存在以下点：c-d=5,c-h=5,b-d=5(与现有的c-d=5一样，

所以不更新，仍旧采用c-d)，b-e=9，取最小的，此时可以有两个选择，假设选择c-d，所以将d点添加到U集合中。U={a,c,b,d}。

此时V-U到U的路径，因为e-d=7<e-b=9,所以e点进行更新，更新为d-e=7;同理d-h=4<c-h=5，所以点h到U的路径更新为d-h=4。

新增加的路径为d-f和d-g。此时选择V-U到U集合的最短路径为d-h=4,所以将h添加到U集合，此时U={a,c,b,d,h}。依次不断选择

下一个距离U集合最短路径的点，并将其添加到U集合，直到将所以顶点添加完毕。实现过程如下图所示：

接下来的代码示例图:

 

代码如下:

 

#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;
typedef struct MGraph
{
    string vexs[60];                   //存放顶点
    int arcs[100][100];                //存放邻接矩阵矩阵
    int vexnum, arcum;                 //总顶点数以及总边数
}MGraph;
typedef struct Closedge
{
    string adjvex;                     
    int lowcost;                       //存放相关顶点间边的权值
}minside[100];

int locateVex(MGraph G, string u)      //找到则返回i，否则返回-1
{
    for (int i = 0; i < G.vexnum; i++)
        if (G.vexs[i] == u)
            return i;
    return -1;
}

void CreateGraphUDG(MGraph &G)         //构造无向图
{
    string v1, v2;                     //两个顶点信息
    int w;                             //两顶点间边的权值
    int i, j, k;
    cout << "请输入顶点数和边数:";
    cin >> G.vexnum >> G.arcum;

    cout << "请输入顶点:";
    for (i = 0; i < G.vexnum; i++)
        cin >> G.vexs[i];

    for (i = 0; i < G.vexnum; i++)     //先将邻接矩阵中所有元素都设为无穷大，这里默认10000为无穷大
        for (j = 0; j < G.vexnum; j++)
            G.arcs[i][j] = 10000;

    cout << "请输入边和权值:" << endl;
    for (k = 0; k < G.arcum; k++)
    {
        cin >> v1 >> v2 >> w;
        i = locateVex(G, v1);
        j = locateVex(G, v2);
        G.arcs[i][j] = G.arcs[j][i] = w;//关于主对角线对称的元素是相等的
    }
    
}

int minimum(minside sz, MGraph G)      //寻找最小
{
    int i = 0, j, k, min;
    while (!sz[i].lowcost)             //如果sz中的第i个元素的权值为0，则i移动到下一个位置
        i++;
    min = sz[i].lowcost;               //将上一步操作后得到的i此步利用，并将此位置对应的权值出入min
    k = i;                             
    for (j = i + 1; j < G.vexnum; j++)//权值进行比较，找出不重复且最小的
    {
        if (sz[j].lowcost > 0 && min > sz[j].lowcost)
        {
            min = sz[j].lowcost;
            k = j;
        }
    }
    return k;
}

void MiniSpanTree_PRIM(MGraph G, string u)//Prim算法
{
    int i, j, k;
    minside closedge;
    k = locateVex(G, u);
    for (j = 0; j < G.vexnum; j++)
    {
        closedge[j].adjvex = u;        //存放顶点
        closedge[j].lowcost = G.arcs[k][j];
    }
    closedge[k].lowcost = 0;           //该点用过后权值归0
    
    cout << "最小生成树各边为:" << endl;
    for (i = 1; i < G.vexnum; i++)
    {
        k = minimum(closedge, G);
        cout << closedge[k].adjvex << "-" << G.vexs[k] << endl;
        closedge[k].lowcost = 0;       //同样权值归0
        for (j = 0; j < G.vexnum; j++)
        {
            if (G.arcs[k][j] < closedge[j].lowcost)
            {
                closedge[j].adjvex = G.vexs[k];
                closedge[j].lowcost = G.arcs[k][j];
            }
        }
    }
}

int main()
{
    MGraph G;
    CreateGraphUDG(G);
    MiniSpanTree_PRIM(G, G.vexs[0]);//这里是默认从第一个顶点开始使用Prim算法
    cout << endl;
    return 0;
}

 

 

 

输出结果:

 

关于克鲁斯卡尔算法博主明天会更新，请耐心等待...