【学习笔记----数据结构19-图的最小生成树】

我们把构造连通网的最小代价生成树称为最小生成树（Minimum  Cost   Spanning Tree）

 

普里姆（Prim）算法

 

也就是说，现在我们已经有一个存储结构

MGraph的G，它的arc二维数组如图所示。数组中我们用65535代表∞

于是普里母算法代码如下。其中INFINITY权值极大值，这里用65535代表，MAXVEX为顶点个数最大值，此处大于等于9即可。分析MiniSpanTree_Prim函数，输入上图中的矩阵后，看看它是如何运行并打印出最小生成树的。

/*Prim 算法生成最小生成树*/

void  MiniSpanTree_Prim(MGraph   G)

{

    int   min,i,j,k;

    int   adjvex[MAXVEX]; //保存相关顶点下标

    int    lowcost[MAXVEX];//保存相关顶点间边的权值

    lowcost[0] = 0;  //初始化第一个权值为0，即v0加入生成树

       //lowcost的值为0，在这里就是此下标的顶点已加入生成树

     adjvex[0]=0; //初始化第一个顶点下标为0

     for(i=1;i<G.numVertexes;i++){

     {

          lowcost[i]=G.arc[0][i];   //将v0顶点与之有边的权值存入数组。

          adjvex[i]=0; //初始化都为v0的下标

     }

       for(i=1;i<G.numVertexes;i++)

       {

               min = INFINTY;   //初始化最小权值为∞

              j=1;k=0;

               while(j<G.numVertexes)

               {

                     //循环全部顶点

                    if(lowcost[j]!=0 &&lowcost[j]<min)

                    {

                          min =lowcost[i];  //让当前权值成为最小值

                          k=j;  //将当前最小值的下标存入k

                     }

                     j++;

                }

                printf(“%d,%d”,adjvex[k],k); //打印当前顶点边中权值最小的边

                lowcost[k] = 0; //将当前顶点权值 设置成0表示此顶点已完成任务

                for(j=1;j<G.numVertexes;j++)

               {

                     if(lowcost[j]!=0  && G.arc[k][j]<lowcost[j])

                        lowcost[j] =G.arc[k][j];

                        adjvex[j] = k;

               }

       }

}

 

1.    程序开始运行，我们前4~6行，创建了两个一维数组lowcost和adjvex，长度都为顶点个数9。

2.    接下来分别给这两个数组的第一个下标位赋值为0，adjvex[0]=0其实意思就是我们现在从v0开始（事实上，最小生成树从哪个顶点开始计算都无所谓，我们假定从v0开始），lowcost[0]=0表示v0已经被纳入到最小生成树中，之后凡是lowcost数组中的值为0就是表示此下标的顶点被纳入最小生成树。

3.    接下来的循环我们读取邻接矩阵的第一行数据。将数值赋值给lowcost数组，所以此时lowcost数组为：{0,10,65535, 65535, 65535,11, 65535, 65535, 65535}，而arjvex则全部为0。此时我们已经完成整个初始化工作，准备开始生成。

4.    接下来的循环过程就是构造最小生成树过程

5.    将min值设置为65535，它的目的是为了之后找到一定范围内的最小权值。j是用来做顶点下标循环的变量，k是用来存储最小权值的顶点下标

6.    循环中不断修改min为当前lowcost数组中最小的值，并用k保留此最小值的顶点下标。经过循环后，min=10,k=1;注意这里有个if判断lowcost[j]!=0表示已经是生成树的顶点不参与最小权值的查找。

7.    打印k=1,adjvex[1]=0，所以结果为(0    1)，表示v0至v1边为最小生成树第一条边。如图

8.    lowcost[k] = 0;这句话的意思是目前k=1我们将lowcost[k]=0就是说顶点v1纳入到最小生成树中。此时lowcost数组值为{0,0,65535, 65535, 65535,11, 65535, 65535, 65535}

9.    接下来的循环，j循环由1至8，因k=1，查找邻接矩阵的第v1行的各个可权值，与lowcost的对应值比较，若更小则修改lowcost值，并将k值存入adjvex数组中。因第v1行有18,16,12均比65535小，所以最终lowcost数组的值为

{0,0,65535, 65535,11,16, 65535,12}

adjvex数组的值为：

{0,0,1,0,0,0,1,0,1}。这里的if判断lowcost[j]!=0也说明v0和v1已经是生成树的顶点不参与最小权值的比对了。

10.  再次循环，由第15行到第26行，此时min=11,k=5,adjvex[5]=0。因此打印结构为（0,5)。表示v0至v5边为最小生成树的第二边，如下图

11.  接下来执行到36行，lowcost数组的值为：{0,0,18,65535,26,0,16,65535,12}。adjvex数组的值为{0,0,1,0,5,0,1,0,1}

12.  之后，依次模拟了。通过不断的转换，构造的过程如图

 

有了上面的推演，普里姆（Prim）算法的实现定义可能就容易理解一些

假设N=(V,{E})是连通图，TE是N上最小生成树中边的集合。算法从U={U₀}(U₀∈V)，TE={}开始。重复执行下述操作：在所有u∈U,v∈V-U的边（u,V）∈E中找一条代价最小的边（u₀,v₀）并入集合TE，同时V0并入U，直至U=V为止。此时TE中必须n-1条边，则T={V,{TE}}为N的最小生成树。

由算法代码中的循环嵌套可得知此算法的时间复杂度为O(n²)

 

克鲁斯卡尔算法

我们可以直接就以边为目标去构建，因为权值是在边上，直接去找最小权值的边来构建生成树也是很自然的想法，只不过构建时要考虑是否会形成环路而已。此时我们就用到了图的存储结构中的边集数组结构。

代码如下：

typedef  struct

{

    int  begin;

int   end;

int   weight;

}Edge;

我们的邻接矩阵通过程序转化如下图右图的边集数组，并且它们按权值从小到大排序。

于是克鲁斯卡尔（Kruskal）算法代码如下，其中MAXEDGE为边数量的极大值，此处大于等于15即可。MAXVEX为顶点个数最大值，此处大于等于9即可。接下来我们模拟一下MiniSpanTree_Kruskal函数

 

void   MiniSpanTree_Kruskal(MGraph   G)

{

      int   i,n,m;

      Edge   edges[MAXEDGE];//定义边集数组

      int    parent[MAXVEX];   //定义一数组来判断边与边是否形成环路

      /*此处省略将邻接矩阵G转化为边集数组edges并按权由小到大排序的代码*/

     for(i=0;i<G.numVertexes;i++)

            parent[i] = 0;

      for(i=0;i<G.numEdges;i++)

      {

           n=Find(parent,edges[i].begin);

           m=Find(parent,edges[i].end);

           if(n!=m)

           {

                 parent[n] = m;

                 print(“(%d,%d)  %d”,edges[i].begin,edges[i].end,edges[i].weight)

           }

      }

}

int   Find(int  *parent,int  f)

{

while(parent[f]>0)

         f=parent[f];

return f;

}

 

1.    声明数组parent，并将它的值都初始化为0，它的作用我们后面慢慢说。

2.    我们开始对边集数组做循环遍历，开始时，i=0。

3.    第10行我调用了Find函数，传入的参数是数组parent和当前权值最小边（v₄,v₇）的begin:4。因为parent中全都是0，所以传出的值使得n=4。

4.    第11行，同样作法，传入（v4,v7）的end:7。传出值使得m=7。

5.    第12~16行，很显然n与m不等，因此parent[4]=7。此时parent数组值为

{0,0,0,0,7,0,0,0,0}，并且打印得到“（4,7）7”。们已经将边（v4,v7）纳入到最小生成树中，

6.    循环返回，执行10~16行，此时i=1，edge[1]得到边（v2,v8）,n=2，m=8,parent[2]=8，打印结果为“（2,8）8”，此时parent数组为{0,0,8,0,7,0,0,0,0}此时parent数组值为{0,0,8,0,7,0,0,0,0}，这也就表示边(v4,v7)和(v2,v8)已经纳入到最小生成树如下图。

7.    再次执行10~16行，此时i=2，edge[2]得到边(v0,v1)，n=0，m=1，parent[0]=1，打印结果为“（0,1）10”，此时parent数组值为{1,0,8,0,7,0,0,0,0}，此时边(v4,v7)、(v2,v8)和(v0,v1)已经纳入到最小生成树。

8.    当i=3、4、5、6、时，分别将边(v0,v5)、(v1,v8) 、(v3,v7) 、(v1,v6)纳入到最小生成树中，如图。此时parent数组值为{1,5,8,7,7,8,0,0,6}，怎么去解读这个数组现在这些数字的意义呢?

 

最右图i=6的粗线连线可以得到，我们其实是有两个连通的边集合A与B中纳入到最小生成树中的，当parent[0] = 1,表示v0和v1已经在生成树的边集合A中。parent[1]=5，表示v5和v8在边集合A中，parent[5]=8表示v5和v8在边集合A中，parent[6]=0表示集合A暂时到头，此时边集合A有v0、v1、v5、v8、v6。我们查看parent中没有查看值，parent[2]=8表示v2和v8在一个集合中，因此v2也在边集合A中。再parent[3]=7、parent[4]=7和parentp[7]=0可知v3,v4,v7在另一个边集B中。

9.    当i=7时，第10行，调用Find函数，会传入参数edges[7]。begin=5。此时第21行，parent[5]=8>0，所以f=8，再循环得parent[8]=6。因parent[6]=0所以Find返回第10行得到n=6。而此时第11行，传入参数edges[7]。end=6得到m=6。此时n=m，不再打印，继续下一循环。这就告诉我们，因为边(v5,v6)使得边集合A形成环路。因此不能将它纳入到最小生成树中

10.  当i=8时，与上面相同，由于边(v1,v2)使得边集合A形成了环路。因此不能将它纳入到最小生成树，

11.  当i=9时，边(v6,v7)，第10行得到n=6，第11行得到m=7，因此parent[6]=7，打印“（6 7）19”,此时parent数组值为{1,5,8,7,7,8,7,0,6}

 

12.  此后的循环均造成环路，最终最小生成树好

定义：假设N=（V,{E}）是连通网，则令最小生成树的初始状态为只有n个顶点而无边的非连通图T={V,{}},图中每个顶点自成一个连通分量。在E中选择代价最小的边，若该边依附的点T中不同的连通分量上，则将此边加入到T中，否则舍去此边而选择下一条代价最小的边。依次类推，直至T中所有顶点都在同一连通分量上为止。

对比两个算法，克鲁斯卡尔算法主要是针对边来展开，边数少时效率会非常高，所以对于稀疏图有很大的优势；而普里姆算法对于稠密图，即边数非常多的情况会更好一些。