（转）最小生成树之普利姆算法、克鲁斯卡尔算法

标签：style   blog   http   color   使用   strong   

                                                                       最小生成树之prim算法

   边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。

   最小生成树（MST）：权值最小的生成树。

   生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。

   构造网的最小生成树必须解决下面两个问题：

    1、尽可能选取权值小的边，但不能构成回路；

    2、选取n－1条恰当的边以连通n个顶点；

    MST性质：假设G＝(V,E)是一个连通网，U是顶点V的一个非空子集。若(u,v)是一条具有最小权值的边，其中u∈U，v∈V－U，则必存在一棵包含边(u,v)的最小生成树。 

1.prim算法

  基本思想：假设G＝(V，E)是连通的，TE是G上最小生成树中边的集合。算法从U＝{u0}（u0∈V）、TE＝{}开始。重复执行下列操作：

   在所有u∈U，v∈V－U的边(u，v)∈E中找一条权值最小的边(u0,v0)并入集合TE中，同时v0并入U，直到V＝U为止。

   此时，TE中必有n-1条边，T=(V，TE)为G的最小生成树。

   Prim算法的核心:始终保持TE中的边集构成一棵生成树。

注意：prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，而kruskal算法的时间复杂度为O(eloge)跟边的数目有关，适合稀疏图。

看了上面一大段文字是不是感觉有点晕啊，为了更好理解我在这里举一个例子，示例如下：

（1）图中有6个顶点v1-v6，每条边的边权值都在图上；在进行prim算法时，我先随意选择一个顶点作为起始点，当然我们一般选择v1作为起始点，好，现在我们设U集合为当前所找到最小生成树里面的顶点，TE集合为所找到的边，现在状态如下：

U={v1}； TE={}；

（2）现在查找一个顶点在U集合中，另一个顶点在V-U集合中的最小权值，如下图，在红线相交的线上找最小值。

通过图中我们可以看到边v1-v3的权值最小为1，那么将v3加入到U集合，（v1，v3）加入到TE，状态如下：

U={v1，v3}； TE={（v1，v3）}；

（3）继续寻找，现在状态为U={v1，v3}； TE={（v1，v3）}；在与红线相交的边上查找最小值。

我们可以找到最小的权值为（v3，v6）=4，那么我们将v6加入到U集合，并将最小边加入到TE集合，那么加入后状态如下：

U={v1，v3，v6}； TE={（v1，v3），（v3，v6）}； 如此循环一下直到找到所有顶点为止。

（4）下图像我们展示了全部的查找过程：

2.prim算法程序设计

（1）由于最小生成树包含每个顶点，那么顶点的选中与否就可以直接用一个数组来标记used[max_vertexes];（我们这里直接使用程序代码中的变量定义，这样也易于理解）；当选中一个数组的时候那么就标记，现在就有一个问题，怎么来选择最小权值边，注意这里最小权值边是有限制的，边的一个顶点一定在已选顶点中，另一个顶点当然就是在未选顶点集合中了。我最初的一个想法就是穷搜了，就是在一个集合中选择一个顶点，来查找到另一个集合中的最小值，这样虽然很易于理解，但是很明显效率不是很高，在严蔚敏的《数据结构》上提供了一种比较好的方法来解决：设置两个辅助数组lowcost[max_vertexes]和closeset[max_vertexes]，lowcost[max_vertexes]数组记录从U到V－U具有最小代价的边。对于每个顶点v∈V－U,closedge[v], closeset[max_vertexes]记录了该边依附的在U中的顶点。

注意：我们在考虑两个顶点无关联的时候设为一个infinity 1000000最大值。

说了这么多，感觉有点罗嗦，还是发扬原来的风格举一个例子来说明，示例如下：

过程如下表：顶点标号都比图中的小1，比如v1为0，v2为1，这里首先选择v1点。

从这个表格可以看到依附到v1顶点的v3的Lowcost最小为1，那么选择v3，选择了之后我们必须要更新Lowcost数组的值，因为记录从U到V－U具有最小代价的边，加入之后就会改变。这里更新Lowcost和更新closeset数组可能有点难理解，

 for (k=1;k<vcount;k++)
            if (!used[k]&&(G[j][k]<lowcost[k]))
                { lowcost[k]=G[j][k];
                closeset[k]=j; }
        }
j为我们已经选出来的顶点，如果G[j][k]<lowcost[k]，则意味着最小权值边发生变化，更新该顶点的最小lowcost权值，依附的顶点肯定就是刚刚选出的顶点j，closeset[k]=j。

这样一直选择下去直到选出所有的顶点。

（2）上面把查找最小权值的边结束了，但是这里有一个问题，就是我们没有存储找到的边，如果要求你输出找到的边那么这个程序就需要改进了，我们刚开始的时候选取的是v1作为第一个选择的顶点，那我们设置一个father[]数组来记录每个节点的父节点，当然v1的父节点肯定没有，那么我们设置一个结束标志为-1，每次找到一个新的节点就将它的父节点设置为他依附的节点，这样就可以准确的记录边得存储了。

测试程序：

测试用例：

1 2 6

1 3 1

1 4 5

2 3 5

2 5 3

3 4 5

3 5 6

3 6 4

5 6 6

4 6 2

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define infinity 1000000

#define max_vertexes 6 

typedef int Graph[max_vertexes][max_vertexes];

void prim(Graph G,int vcount,int father[])

{    

int i,j,k; 

    int lowcost[max_vertexes];

int closeset[max_vertexes],used[max_vertexes];

int min;  

for (i=0;i<vcount;i++)     

  {

/* 最短距离初始化为其他节点到1号节点的距离 */   

    lowcost[i]=G[0][i];

    /* 标记所有节点的依附点皆为默认的1号节点 */

     closeset[i]=0;      

  used[i]=0;    

    father[i]=-1;      

}    

used[0]=1; /*第一个节点是在s集合里的*/

/* vcount个节点至少需要vcount-1条边构成最小生成树 */  

  for (i=1;i<=vcount-1;i++)      

   {       

 j=0;

     min = infinity;

       /* 找满足条件的最小权值边的节点k */      

     for (k=1;k<vcount;k++)

         /* 边权值较小且不在生成树中 */     

 if ((!used[k])&&(lowcost[k]<min)) 

    {

              min =  lowcost[k];

              j=k;

            }       

    father[j]=closeset[j];   

printf("%d %d\n",j+1,closeset[j]+1);//打印边   

used[j]=1;;//把第j个顶点并入了U中     

for (k=1;k<vcount;k++)

         /* 发现更小的权值 */       

   if (!used[k]&&(G[j][k]<lowcost[k]))       

{ 

                  lowcost[k]=G[j][k];/*更新最小权值*/       

      closeset[k]=j;;/*记录新的依附点*/

    }      

   }

}

int main()

{

FILE *fr;

int i,j,weight;

Graph G;

int fatheer[max_vertexes];

for(i=0; i<max_vertexes; i++)

for(j=0; j<max_vertexes; j++)

G[i][j] = infinity;

fr = fopen("prim.txt","r");

if(!fr)

{

printf("fopen failed\n");

exit(1); 

}

while(fscanf(fr,"%d%d%d", &i, &j, &weight) != EOF)

{

G[i-1][j-1] = weight;

G[j-1][i-1] = weight;

}

prim(G,max_vertexes,fatheer);

return 0;

}

程序结果：

3 1

6 3

4 6

2 3

5 2

请按任意键继续. . .

                                                                                          最小生成树之kruskal算法

1.kruskal算法

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

示例如下：

图中先将每个顶点看作独立的子图，然后查找最小权值边，这条边是有限制条件的，边得两个顶点必须不在同一个图中，如上图，第一个图中找到最小权值边为（v1，v3），且满足限制条件，继续查找到边（v4，v6），（v2，v5），（v3，v6），当查找到最后一条边时，仅仅只有（v2，v3）满足限制条件，其他的如（v3，v4），（v1，v4）都在一个子图里面，不满足条件，至此已经找到最小生成树的所有边。

2.kruskal算法程序设计

由于我们要查找边权值最小的边，那么我们的第一步应该把边权值排序，这样就可以很快查找到权值最小的边，为了简化程序设计，我们不使用其他的数据结构，仅仅设立一个结构体数组来存储边，用一个标记数组来标记哪些边已经被选择（实际程序设计的时候没有用到标记数组）；

解决了边得存储和排序问题，现在是算法最关键的就是怎么判断边的两个顶点不在一个子图里面，一个简单的办法是设立一个辅助数组f[n]，初始化如下：

void Initialize()

{

int i;

for(i=0; i<n;i++)

 f[i] = i;

}

如此初始化是为了让每个顶点各自为一个图，如果找到一条边（i,j）那么做如下标记：(i<j)

void Mark_same(int i, int j)

{

//找到i的父节点

while(f[i] != i)

{

i= f[i];

}

f[j] = i;//将j指向其父节点

}

上面的标记过程也给了我们怎么判断两个顶点是否在一个图中找到了方法，即判断其父节点是否相同，相同则是在一个图里；

int Is_same(int i, int j)

{

//找到i的父节点

while(f[i] != i)

{

i= f[i];

}

//找到i的父节点

while(f[j] != j)

{

j= f[j];

}

return i == j ? 1 : 0;

}

注意：实际设计程序的时候不用标记已选边，因为已选择的边会讲端点集合合并为一个集合，从而在判断是否为同一集合的时候就可以排除了。

测试用例：

Kruskal.txt

0 1 6

0 2 1

0 3 5

1 2 5

1 4 3

2 3 5

2 4 6

2 5 4

4 5 6

3 5 2

测试程序：

#include <stdio.h>

#include <stdlib.h>

#define MAX 100

#define N 6//顶点数目 

/* 定义边(x,y)，权为w */

typedef struct

{

int x,y;

int w;

}edge;

edge e[MAX];

/* father[x]表示x的父节点 */

int father[N];

/* 比较函数，按权值(相同则按x坐标)非降序排序 */

int cmp(const void *a, const void *b)

{

if ((*(edge *)a).w == (*(edge *)b).w)

{

return (*(edge *)a).x - (*(edge *)b).x;

}

return (*(edge *)a).w - (*(edge *)b).w;

}

/* 判断集合是否相同 */

int Is_same(int i, int j)

{

//找到i的父节点

while(father[i] != i)

{

i =  father[i];

}

//找到i的父节点

while(father[j] != j)

{

j = father[j];

}

return i == j ? 1 : 0;

}

/* 合并x,y所在的集合 */

void Mark_same(int i, int j)

{

int temp;

if(i > j)

{

temp = i;

i = j;

j = temp;

} 

//找到i的父节点

while(father[i] != i)

{

i= father[i];

}

father[j] = i;//将j指向其父节点

}

//初始化 father数组 

void Initialize()

{

int i;

for(i=0; i<N;i++)

 father[i] = i;

}

/* 主函数 */

int main()

{

int i = 0,j, n;

int x, y;

  FILE *fr;

fr = fopen("kruskal.txt","r");

if(!fr)

{

printf("fopen failed\n");

exit(1); 

}

/* 读取边信息并初始化集合 */

while(fscanf(fr,"%d %d %d", &e[i].x, &e[i].y, &e[i].w) != EOF)

i++;

/* 将边排序 */

qsort(e, i, sizeof(edge), cmp);

Initialize();

for (i = 0; i < N; i++)

{

if(!Is_same(e[i].x, e[i].y))

{

printf("%d %d\n",e[i].x+1, e[i].y+1);

Mark_same(e[i].x, e[i].y);

}

}

system("pause");

return 0;

}

程序结果：

1 3

4 6

2 5

3 6

1 4

2 3

请按任意键继续. . .

（转）最小生成树之普利姆算法、克鲁斯卡尔算法,布布扣,bubuko.com

（转）最小生成树之普利姆算法、克鲁斯卡尔算法

标签：style   blog   http   color   使用   strong   

原文地址：http://www.cnblogs.com/PJQOOO/p/3855017.html