最小生成树之Prim算法

Posted 2020-09-29 liguangsunls

Prim算法：

如果N = （V。{E}）是连通网，TE是N上最小生成树中边的集合。算法从U={u0}（u0属于V），TE={}開始，反复运行下述操作：在全部u属于U，v属于V-U的边（u,v）属于E中找到一条代价最小的边(u0,v0)并入集合TE,同一时候v0并入U，直至U=V为止，此时TE中必有n-1条边，则T=（V。{TE}）为N的最小生成树.

为实现这个算法，需附设一个辅助数组closedge,以记录从U到V-U具有最小代价的边。

对每一个顶点vi属于V-U,在辅助数组中存在一个对应分量closedge[i-1],它包含两个域，lowcost域存储该边的权,vex域存储该边依附的在U中的顶点。

考虑例如以下无向网：

邻接矩阵：

其最小生成树为:

Prim算法过程(图以邻接矩阵表示，如果从顶点a出发)：

1.首先初始化辅助数组，将顶点u纳入U集：

2.迭代n-1次，n为顶点数，每次迭代都调用mininum方法返回一个最小k值，然后输出生成树的边，并将第k顶点纳入u集，最后更新辅助数组。

比方第一次循环时。k = 2(非常显然最小权为1=min{6,1,5},序号为2，即k = 2);输出生成树的边(a,c),将邻接矩阵第k顶点纳入U集(顶点c),即将lowcost置0，此时相应的辅助数组例如以下：

以下将更新辅助数组，即挨个比較辅助数组与邻接表第k行的元素，假设邻接表的相应值小，那么就替换辅助数组值.

此时第一轮循环结束，以下进入第二次循环，此时k = 5......

实现：

/**********************************************
Prim算法求最小生成树
by Rowandjj
2014/7/1
***********************************************/
#include<iostream>
using namespace std;
//---------------------------------------
#define MAX_VERTEX_NUM 20//边的最大值
#define INFINTY 65535//代表无穷大

typedef struct _ARC_
{
    int adj;//顶点关系类型
    char *info;//弧信息
}Arc,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct _GRAPH_
{
    char vexs[MAX_VERTEX_NUM];//顶点向量
    AdjMatrix arcs;//邻接矩阵
    int vexnum,arcnum;//顶点数、弧数
}Graph;

//----------------------------------------
typedef struct _ARRAY_//辅助数组
{
    char adjvex;//存储顶点
    int lowcost;//存储权值
}minside[MAX_VERTEX_NUM];

//----------------------------------------
//图操作
int LocateVex(Graph G,char u);
bool CreateAN(Graph *G);//构建无向网
void Display(Graph G);//打印无向网
//prim算法
void MiniSpanTree_PRIM(Graph G,char u);//用普里姆算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边 
int mininum(minside SZ,Graph G);//求closedge.lowcost的最小正值
//---------------------------------------
int LocateVex(Graph G,char u)
{
    int i;
    for(i = 0; i < G.vexnum; i++)
    {
        if(G.vexs[i] == u)
        {
            return i;
        }
    }
    return -1;
}
bool CreateAN(Graph *G)
{
    int i,j,k;
    int IncInfo;
    char va,vb;//顶点
    int w;//权
    char *info;
    char str[20];

    cout<<"请输入无向网G的顶点数,边数,边是否含其他信息(是:1,否:0):\n";
    cin>>G->vexnum;
    cin>>G->arcnum;
    cin>>IncInfo;

    cout<<"输入顶点的值:";
    //初始化顶点
    for(i = 0; i < G->vexnum; i++)
    {
        cin>>G->vexs[i];
    }    
    //初始化邻接矩阵
    for(i = 0; i < G->vexnum; i++)
    {
        for(j = 0; j < G->vexnum; j++)
        {
            G->arcs[i][j].adj = INFINTY;
            G->arcs[i][j].info = NULL;
        }
    }
    cout<<"依次输入每条边的两个顶点及权值"<<endl;
    //初始化边
    for(k = 0; k < G->arcnum; k++)
    {
        cin>>va;
        cin>>vb;
        cin>>w;

        i = LocateVex(*G,va);
        j = LocateVex(*G,vb);

        G->arcs[i][j].adj = w;
        G->arcs[j][i].adj = w;
        if(IncInfo)//弧信息
        {
            cout<<"输入该边的相关信息:";
            cin>>str;
            w = strlen(str)+1;
            if(w)
            {
                info = (char *)malloc(sizeof(char)*(w+1));
                strcpy(info,str);
                G->arcs[i][j].info = G->arcs[j][i].info = info;
            }
        }
    }

    return true;
}
void Display(Graph G)
{
    int i,j;
    cout<<"顶点:";
    for(i = 0; i < G.vexnum; i++)
    {
        cout<<G.vexs[i]<<"    ";
    }
    cout<<"\n邻接矩阵:\n";
    for(i = 0; i < G.vexnum; i++)
    {
        for(j = 0; j < G.vexnum; j++)
        {
            cout<<G.arcs[i][j].adj<<"    ";
        }
        cout<<endl;
    }
    cout<<endl;
}
//---------------------------------------------------------
int mininum(minside SZ,Graph G)
{
    int i = 0,j;
    int min;//存储最小权值
    int k;//存储权值最小的元素在数组中的位置
    while(!SZ[i].lowcost)//忽略lowcost为0的元素
    {
        i++;
    }
    min = SZ[i].lowcost;
    k = i;
    for(j = i+1; j< G.vexnum; j++)
    {
        if(SZ[j].lowcost > 0 && min > SZ[j].lowcost)//忽略lowcost为0的元素
        {
            min = SZ[j].lowcost;
            k = j;
        }
    }
    return k;
}
void MiniSpanTree_PRIM(Graph G,char u)
{
    minside closedge;//辅助数组
    int i,j,k;
    k = LocateVex(G,u);
    if(k==-1)
    {
        return;
    }
    //初始化辅助数组
    for(i = 0; i < G.vexnum; i++)
    {
        if(k != i)
        {
            closedge[i].adjvex = u;//复制顶点
            closedge[i].lowcost = G.arcs[k][i].adj;//复制权
        }
    }
    closedge[k].lowcost = 0;//初始,将第k顶点纳入U集
    cout<<"最小代价生成树的各条边为:\n";
    for(i = 1; i < G.vexnum; i++)//n个顶点的图的最小生成树有n-1条边
    {
        k = mininum(closedge,G);
        cout<<closedge[k].adjvex<<"--->"<<G.vexs[k]<<endl;//输出生成树的边
        
        closedge[k].lowcost = 0;//第k顶点并入U集
        
        //更新辅助数组
        for(j = 0; j < G.vexnum; j++)
        {
            if(closedge[j].lowcost > G.arcs[k][j].adj)
            {
                closedge[j].adjvex = G.vexs[k];//更新顶点名
                closedge[j].lowcost = G.arcs[k][j].adj;//更新权
            }
        }
    }
    cout<<endl;
}

//---------------------------------------------------------
int main()
{
    Graph g;
    CreateAN(&g);
    Display(g);
    MiniSpanTree_PRIM(g,'a');
    return 0;
}

測试：