最小生成树及其经典算法（普里姆算法和克鲁斯卡尔算法）

对于网结构的最小成本：就是n个顶点，用n-1条边把一个连通图连接起来，并且使得权值的和最小。

我们在讲图的定义和术语时，曾经提到过，一个连通图的生成树是一个极小的连通子图，它含有图中全部的顶点，但只有足以构成一棵树的n-1条边。我们把构造连通网的最小代价生成树称为最小生成树（Minimum Cost SpanningTree）。即一个无向图的生成树，是原图的一个子图，并且包含图中的所有顶点，但是只有足够数量的边来连通这些顶点，并且使得生成树的总权重（边的权重之和）最小。找连通网的最小生成树，经典的有两种算法，普里姆算法和克鲁斯卡尔算法。

普里姆（Prim）算法

就是说，现在我们已经有了一个存储结构为MGragh的G。G有9个顶点。数组中的我们用65535来代表∞。
于是普里姆（Prim）算法代码如下，左侧数字为行号。其中INFINITY为权值极大值，不妨是65535，MAXVEX为顶点个数最大值，此处大于等于9即可。现在假设我们自己就是计算机，在调用MiniSpanTree_Prim函数，输入上述的邻接矩阵后，看看它是如何运行并打印出最小生成树的。

/*  Prim算法生成最小生成树  */
void  MiniSpanTree_Prim(MGraph  G)
{
int  min,  i,  j,  k;
/*  保存相关顶点下标  */
int  adjvex[MAXVEX];      
/*  保存相关顶点间边的权值  */
int  lowcost[MAXVEX];     
/*  初始化第一个权值为0，即v0加入生成树  */
/*  lowcost的值为0，在这里就是此下标的顶点已经加入生成树  */
lowcost[0]  =  0;     
/*  初始化第一个顶点下标为0  */
adjvex[0]  =  0;      
/*  循环除下标为0外的全部顶点  */
for  (i  =  1;  i  <  G.numVertexes;  i++)  
{
/*  将v0顶点与之有边的权值存入数组  */
lowcost[i]  =  G.arc[0][i];      
/*  初始化都为v0的下标  */
adjvex[i]  =  0;      
}
for  (i  =  1;  i  <  G.numVertexes;  i++)
{
/*  初始化最小权值为∞，  */
/*  通常设置为不可能的大数字如32767、65535等  */
min  =  INFINITY;     
j  =  1;  
k  =  0;
/*  循环全部顶点  */
while  (j  <  G.numVertexes)     
{
/*  如果权值不为0且权值小于min  */
if  (lowcost[j]  !=  0  &&  lowcost[j]  <  min)
{          
/*  则让当前权值成为最小值  */
min  =  lowcost[j];   
/*  将当前最小值的下标存入k  */
k  =  j;   
}
j++;
}
/*  打印当前顶点边中权值最小边  */
printf("(%d,%d)",  adjvex[k],  k);          
/*  将当前顶点的权值设置为0，表示此顶点已经完成任务  */
lowcost[k]  =  0;     
/*  循环所有顶点  */
for  (j  =  1;  j  <  G.numVertexes;  j++)  
{/*  若下标为k顶点各边权值小于此前这些顶点未被加入生成树权值  */
if  (lowcost[j]  !=  0  &&  G.arc[k][j]  <  lowcost[j])
{          
/*  将较小权值存入lowcost  */
lowcost[j]  =  G.arc[k][j];      
/*  将下标为k的顶点存入adjvex  */
adjvex[j]  =  k;      
}}}}

1．程序开始运行，我们由第4～5行，创建了两个一维数组lowcost和adjvex，长度都为顶点个数9。它们的作用我们慢慢细说。
2．第6～7行我们分别给这两个数组的第一个下标位赋值为0，adjvex[0]=0其实意思就是我们现在从顶点v0开始（事实上，最小生成树从哪个顶点开始计算都无所谓，我们假定从v0开始），lowcost[0]=0就表示v0已经被纳入到最小生成树中，之后凡是lowcost数组中的值被设置为0就是表示此下标的顶点被纳入最小生成树。
3．第8～12行表示邻接矩阵的第一行数据。将数值赋值给lowcost数组，所以此时lowcost数组值为{0,10,65535,65535,65535,11,65535,65535,65535}，而adjvex则全部为0。此时，我们已经完成了整个初始化的工作，准备开始生成。
4．第13～36行，整个循环过程就是构造最小生成树的过程。
5．第15～16行，将min设置为了一个极大值65535，它的目的是为了之后找到一定范围内的最小权值。j是用来做顶点下标循环的变量，k是用来存储最小权值的顶点下标。
6．第17～25行，循环中不断修改min为当前lowcost数组中最小值，并用k保留此最小值的顶点下标。经过循环后，min=10，k=1。注意19行if判断的lowcost[j]!=0表示已经是生成树的顶点不参与最小权值的查找。
7．第26行，因k=1，adjvex[1]=0，所以打印结果为(0,1)，表示v0至v1边为最小生成树的第一条边。
8．第27行，此时因k=1我们将lowcost[k]=0就是说顶点v1纳入到最小生成树中。此时lowcost数组值为{0,0,65535,65535,65535,11,65535,65535,65535}。
9．第28～35行，j循环由1至8，因k=1，查找邻接矩阵的第v1行的各个权值，与low-cost的对应值比较，若更小则修改low-cost值，并将k值存入adjvex数组中。因第v1行有18、16、12均比65535小，所以最终lowcost数组的值为：{0,0,18,65535,65535,11,16,65535,12}。adjvex数组的值为：{0,0,1,0,0,0,1,0,1}。这里第30行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}。ad-jvex数组的值为：{0,0,1,0,5,0,1,0,1}。12．之后，相信大家也都会自己去模拟了。通过不断的转换。
有了这样的讲解，再来介绍普里姆（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的最小生成树。
由算法代码中的循环嵌套可得知此算法的时间复杂度为O(n2)。

克鲁斯卡尔（Kruskal）算法

现在我们来换一种思考方式，普里姆（Prim）算法是以某顶点为起点，逐步找各顶点上最小权值的边来构建最小生成树的。这就像是我们如果去参观某个展会，例如世博会，你从一个入口进去，然后找你所在位置周边的场馆中你最感兴趣的场馆观光，看完后再用同样的办法看下一个。可我们为什么不事先计划好，进园后直接到你最想去的场馆观看呢？事实上，去世博园的观众，绝大多数都是这样做的。
同样的思路，我们也可以直接就以边为目标去构建，因为权值是在边上，直接去找最小权值的边来构建生成树也是很自然的想法，只不过构建时要考虑是否会形成环路而已。此时我们就用到了图的存储结构中的边集数组结构。以下是edge边集数组结构的定义代码：

/*  对边集数组Edge结构的定义  */
typedef  struct
{
 int  begin;
 int  end;
 int  weight;
}  
Edge;

我们将图7-6-3的邻接矩阵通过程序转化为图7-6-7的右图的边集数组，并且对它们按权值从小到大排序。
图7-6-7
于是克鲁斯卡尔（Kruskal）算法代码如下，左侧数字为行号。其中MAXEDGE为边数量的极大值，此处大于等于15即可，MAXVEX为顶点个数最大值，此处大于等于9即可。现在假设我们自己就是计算机，在调用MiniSpanTree_Kruskal函数，输入图7-6-3右图的邻接矩阵后，看看它是如何运行并打印出最小生成树的。

/*  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++)
/*  初始化数组值为0  */
parent[i]  =  0;          
/*  循环每一条边  */
for  (i  =  0;  i  <  G.numEdges;  i++)
{
n  =  Find(parent,  edges[i].begin);
m  =  Find(parent,  edges[i].end);
/*  假如n与m不等，说明此边没有与现有生成树形成环路  */
if  (n  !=  m)            
{
/*  将此边的结尾顶点放入下标为起点的parent中  */
/*  表示此顶点已经在生成树集合中  */
parent[n]  =  m;          
printf("(%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;}

以上代码体现的思路是使用Kruskal算法生成最小生成树。首先将图的邻接矩阵转化为边集数组，并按照边的权值从小到大排序。然后初始化一个数组parent，用来判断边与边是否形成环路。接着循环遍历每一条边，找到边的起始顶点的尾部下标n和结束顶点的尾部下标m。如果n和m不相等，表示此边没有和现有生成树形成环路，将此边的结束顶点放入下标为起点的parent中，表示此顶点已经在生成树集合中。最后输出生成的最小生成树的边信息。

克鲁斯卡尔（Kruskal）算法的实现定义：
假设N=(V,{E})是连通网，则令最小生成树的初始状态为只有n个顶点而无边的非连通图T={V,{}}，图中每个顶点自成一个连通分量。在E中选择代价最小的边，若该边依附的顶点落在T中不同的连通分量上，则将此边加入到T中，否则舍去此边而选择下一条代价最小的边。依次类推，直至T中所有顶点都在同一连通分量上为止。
此算法的Find函数由边数e决定，时间复杂度为O(loge)，而外面有一个for循环e次。所以克鲁斯卡尔算法的时间复杂度为O(eloge)。
对比两个算法，克鲁斯卡尔算法主要是针对边来展开，边数少时效率会非常高，所以对于稀疏图有很大的优势；而普里姆算法对于稠密图，即边数非常多的情况会更好一些。