数据结构之Prim算法

在进行最小生成树算法之前，还是老规矩先来熟悉熟悉基本的概念。

生成树

连通图G的一个子图如果是一颗包含G的所有顶点的树，则该子图称为G的生成树（Spanning Tree)。由于n个顶点的连通图至少有n-1条边，而所包含n-1条边及n个顶点的连通图都是无回路的树。

极小连通子图

极小是指边数最少（和前面的极大连通子图有区别传送门），在生成树中添加任意一条属于原图的边必定会产生回路，因为西南添加的边使其所依附的两个顶点之间有了第二条路径。若生成树中减少任意一条边，则必然成为非连通图。

由深度优先搜索得到的为深度优先生成树（DFS生成树），由广度优先搜索得到的为广度优先生成树（BFS生成树）

最小生成树

如果连通图是一个网，称该网所有生成树中权值总和最小的生成树为最小生成树（又名最小代价生成树）。

图的生成树有很多种，一般不采用穷举法比较后找出最小生成树，而是采用MST（most small tree)性质：

设G=（V,E)是一个连通带权图，U是顶点集V的一个真子集。若（u,v）是G中一个端点在U中（即u∈U）而另一个端点不在U中（即v∈V-U）且具有最小权值的一条边，则一定存在一颗包含边（u,v）的最小生成树。

上述性质一般有两种构造最小生成树的方法：Prim算法、Kruskal算法

先来介绍一下Prim算法

1、初始化U={u0}（u0∈V），TE={}
2、在所有u∈U，v∈V-U的边（u,v）∈E中，选一条权值最小的边（ui,vj)并入集合TE时将Vｉ并入U
3、重复2，直到U=V为止。

还是举个例子吧

算法过程 ：

1、V={1，2，3，4，5，6}，U={}，TE={}。初始化过程从u0=1开始，则U={1}，V-U={2，3，4，5，6}。找一个顶点在U中，而另一个顶点在V-U中，且权值最小的边，分析后得到（1，3）为最小生成树的第一条边，将边（1，3）加入TE顶点3加入U。故现在U={1，3}，TE={（1，3）}，V-U={2，4，5，6}，如上图b所示。

2、U={1，3}，V-U={2，4，5，6}。在以U中的顶点为出发点，V-U中的顶点为终止点的边中，找到权值最小的边（3，6）作为第二条最小边加入TE，顶点6加入U中。此时U={1，3，6），TE＝｛（１，３），（３，６）｝，V－U＝｛２，４，５）。如上图C所示。

重复上述算法，直至最后V=U为止。此时U={1，3，6，4，2，5}，TE={（1，3），（3，6），（6，4），（3，2），（2，5）}，T=（U，TE），时连通图的最小生成树。

PS：在进行Prim算法时，若连通图中存在权值相同的边，则得到的最小生成树可能不唯一

the code

#include<stdio.h>
#define max 100
int creatcost(int cost[][max])
{
    int vexnum,arcnum,i,j,k,v1,v2,w;
    printf("\n input the vernum ,arcnum：");
    scanf("%d,%d",&vexnum,&arcnum);
    for(i=1;i<=vexnum;i++)
    for(j=1;j<=vexnum;j++)
        cost[i][j]=32767;       /*32767表示无穷大*/
    for(k=1;k<=arcnum;k++)
    {
        printf("v1,v2,w=");
        scanf("%d,%d,%d",&v1,&v2,&w);
        cost[v1][v2]=w;
        cost[v2][v1]=w;
    }
    return vexnum;
}
void prim(int cost[][max],int vexnum)
{
    int lowcost[max],closevert[max],i,j,k,min;
    for(i=1;i<=vexnum;i++)
    {
        lowcost[i]=cost[1][i];
        closevert[i]=1;
    }
    closevert[1]=-1;
    for(i=2;i<=vexnum;i++)
    {
        min=32767;
        k=0;
        for(j=1;j<=vexnum;j++)
        if(closevert[j]!=-1&&lowcost[j]<min)
        {
            min=lowcost[j];
            k=j;
        }
        if(k)
        {
            printf("(%d,%d)%2d\n",closevert[k],k,lowcost[k]);
            closevert[k]=-1;
            for(j=2;j<=vexnum;j++)
            {
                if(closevert[j]!=-1&&cost[k][j]<lowcost[j])
                {
                    lowcost[j]=cost[k][j];
                    closevert[j]=k;
                }
            }
        }
    }
}
int main()
{
    int vexnum;
    int cost[max][max];
    vexnum=creatcost(cost);
    printf("the prim's least spanning tree's vexnum and arcnum:\n");
    prim(cost,vexnum);
    return 0;
}

运行截图

总结

代码还是有些难以理解，但是如果将Prim算法的思想理解清楚了，那么以后也就不难理解其应用了，该算法是以邻接矩阵为存储结构去实现的，邻接矩阵有一个优势就是很容易理解两个顶点之间的关系，尤其是其中的权值。