Kruskal算法说明及图解
Kruskal算法的思想、证明及步骤
Kruskal算法的思想、证明及步骤Kruskal算法思想：把n个顶点看成看成n棵分离的树（每棵树只有⼀个顶点），每次选取可连接两个分离树中权值最⼩的边把两个分离的树合成⼀个新的树取代原来的两个分离树，如果重复n-1步后便得到最⼩⽣成树。
Kruskal算法步骤：T0存放⽣成树的边，初值为空C(T0) 最⼩⽣成树的权，初值为0VS 分离树顶点的集合，初值为 { {v1} {v2} … {v n} }A B W分别为边的顶点和权值数组，由⽤户输⼊1) T0←0, C(T0)←0, VS←{ {v1} {v2} … {v n} }, A, B, W按W排序后构成队列Q2) If n(VS)==1 then stop else goto 33) 取Q第⼀组数组(u, v, w) 并从Q中将其删除.4) If u, v 属于同⼀个集合 then goto 3 else 分属两个集合X, Y, goto 5.5) T0←T0∪(u, v), C(T0)←C(T0)+w, VS←VS-X-Y+X∪Y goto 2.Kruskal算法证明：树定义：⽆圈连通图。
引理1：⼀个图是树等价于⼀个图⽆圈且任意不相关联的顶点u, v ，图G+(u, v)则必存在唯⼀⼀个圈。
设由Kruskal算法⽣成的T0序列为e1, e2, e3 … e v-1，假设其不是最⼩⽣成树。
任意最⼩⽣成树T定义函数f(T)：T0中不存在于T中边在T0的下标。
设T1是使f(T)最⼤的变量，设f(T1)=k，即e k不存在于T1中，T1为树且e k不在T1中，所以由引理1得T1+e k必存在圈C，C上必有e,k ≠e k，e,k不在T0中。
现令T2 = T1 - e,k + e k，则T2也为⽣成树但由Kruskal算法可知e k是使e1, e2 … e k-1, e k⽆圈的权值最⼩的边，e1, e2 … e k-1, e ,k是树的⼦图必⽆圈故e,k的权值必定⼩于e k，即T2的总权值不⼤于T1的权值，因T1是最⼩⽣成树，故必T2也是最⼩⽣成树，但f(T2)＞k与k是f函数最⼤取值⽭盾，故T0是最⼩⽣成树。
Kruskal算法
最小生成树的Kruskal算法Kruskal算法基本思想：每次选不属于同一连通分量(保证不生成圈)且边权值最小的顶点，将边加入MST，并将所在的2个连通分量合并，直到只剩一个连通分量排序使用Quicksort(O(eloge))检查是否在同一连通分量用Union-Find，每次Find和union运算近似常数Union-Find使用rank启发式合并和路径压缩总复杂度O(eloge)=O(elogv) (因为e<n(n-1)/2)}constmaxn=100;maxe=maxn*maxn;typeedge=recorda,b :integer; //边的2个顶点len :integer; //边的长度end;varedges :array[0..maxe]of edge; //保存所有边的信息p,r :array[0..maxn]of integer; //p保存i的父亲节点，r用来实现Union-Find的rank启发式n,e :integer; //n为顶点数，e为边数procedure swap(a,b:integer); //交换beginedges[0]:=edges[a];edges[a]:=edges[b];edges[b]:=edges[0];end;procedure quicksort(l,r:integer); //快速排序varx,i,j :integer;beginx:=edges[random(r-l+1)+l].len;i:=l;j:=r;repeatwhile edges[i].len<x do inc(i);while edges[j].len>x do dec(j);if i<=j thenbeginswap(i,j);inc(i);dec(j);enduntil i>j;if l<j then quicksort(l,j);if i<r then quicksort(i,r);end;procedure init;vari :integer;beginassign(input,'g.in');reset(input);readln(n,e);for i:=1 to e do readln(edges[i].a,edges[i].b,edges[i].len); //从文件读入图的信息for i:=1 to n do p[i]:=i; //初始化并查集randomize;quicksort(1,e); //使用快速排序将边按权值从小到大排列end;function find(x:integer):integer; //并查集的Find，用来判断2个顶点是否属于一个连通分量beginif x<>p[x] then p[x]:=find(p[x]);find:=p[x]end;procedure union(a,b:integer); //如果不属于且权值最小则将2个顶点合并到一个连通分量vart :integer;begina:=find(a);b:=find(b);if r[a]>r[b] then begin t:=a;a:=b;b:=t end;if r[a]=r[b]then inc(r[a]);p[a]:=b;end;procedure kruskal; //主过程varen :integer; //en为当前边的编号count :integer; //统计进行了几次合并。
库鲁斯卡尔(Kruskal)算法
贪心策略是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值(或较优解)的一种解题方法。
Ⅰ、库鲁斯卡尔（Kruskal）算法【定义4】设图G=（V，E）是一简单连通图，｜V｜ =n,｜E｜=m,每条边ei都给以权W ，W 假定是边e 的长度（其他的也可以），i=1，2，3，...，m。
求图G的总长度最短的树，这就是最短树问题。
kruskal算法的基本思想是：首先将赋权图G的边按权的升序排列，不失一般性为：e ,e ,......,e 。
其中W ≤W ，然后在不构成回路的条件下择优取进权最小的边。
其流程如下：（1）对属于E的边进行排序得e ≤e ≤...... ≤e 。
（2）初始化操作 w←0，T←ф，k←0，t←0；（3）若t=n-1，则转（6），否则转（4）（4）若T∪｛e ｝构成一回路，则作【k←k+1，转（4）】（5） T←T∪{ e }，w←w+ w ，t←t+1，k←k+1，转（3）（6）输出T，w，停止。
下面我们对这个算法的合理性进行证明。
设在最短树中，有边〈v ，v 〉，连接两顶点v ，v ，边〈v ，v 〉的权为wp，若〈v ，v 〉加入到树中不能保证树的总长度最短，那么一定有另一条边〈v ，v 〉或另两条边〈v ，v 〉、〈v ，v 〉，且w<vi，vj><wp或w<vi，vk>+w〈vk，vj〉<wp，因为〈v ，v 〉、〈v ，v 〉不在最短树中，可知当〈v ，v 〉、〈v ，v 〉加入到树中时已构成回路，此时程序终止。
因为〈v ，v 〉∈ T，〈v ，v 〉∈T且w〈vI，vk〉+w〈vk，vj〉<w p，与程序流程矛盾。
普林（Prim）算法：Kruskal算法采取在不构成回路的条件下，优先选择长度最短的边作为最短树的边，而Prim则是采取了另一种贪心策略。
已知图G=（V，E），V={v ，v ，v ，...， v }，D=（d ）是图G的矩阵，若〈v ，v 〉∈E，则令dij=∞，并假定dij=∞Prim算法的基本思想是：从某一顶点（设为v ）开始，令S←｛v ｝，求V/S中点与S中点v 距离最短的点，即从矩阵D的第一行元素中找到最小的元素，设为d ，则令S ←S∪ { v }，继续求V/S中点与S的距离最短的点，设为v ,则令S←S∪{ v }，继续以上的步骤，直到n个顶点用n-1条边连接起来为止。
kruskal算法
kruskal算法百科名片K r u s k a l算法每次选择n- 1条边，所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。
注意到所选取的边若产生环路则不可能形成一棵生成树。
K r u s k a l算法分e 步，其中e 是网络中边的数目。
按耗费递增的顺序来考虑这e 条边，每次考虑一条边。
当考虑某条边时，若将其加入到已选边的集合中会出现环路，则将其抛弃，否则，将它选入。
目录[隐藏]Kruskal算法普里姆算法（prim算法）Kruskal算法普里姆算法（prim算法）[编辑本段]Kruskal算法算法定义克鲁斯卡尔算法假设WN=(V,{E}) 是一个含有n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有n 棵树的一个森林。
之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。
依次类推，直至森林中只有一棵树，也即子图中含有n-1条边为止。
举例描述初始时没有任何边被选择。
边（ 1 , 6）是最先选入的边，它被加入到欲构建的生成树中，得到图1 3 - 1 2 c。
下一步选择边（3，4）并将其加入树中（如图1 3 - 1 2 d所示）。
然后考虑边( 2，7 ，将它加入树中并不会产生环路，于是便得到图1 3 - 1 2 e。
下一步考虑边（2，3）并将其加入树中（如图1 3 - 1 2 f所示）。
在其余还未考虑的边中，（7，4）具有最小耗费，因此先考虑它，将它加入正在创建的树中会产生环路，所以将其丢弃。
此后将边（5，4）加入树中，得到的树如图13-12g 所示。
下一步考虑边（7，5），由于会产生环路，将其丢弃。
最小生成树(Kruskal算法)
三、方案解决：
在本题中我们将采用 Kruskal 算法来构造最小生成树。 从题目所给赋权图中我们可以得到该图的邻接矩阵为：
⎡ 0 20 0 0 0 23 1 ⎤ ⎢20 0 15 0 0 0 4 ⎥ ⎢ ⎥ ⎢ 0 15 0 3 0 0 9 ⎥ ⎢ ⎥ G = ⎢ 0 0 3 0 17 0 16 ⎥ ⎢ 0 0 0 17 0 28 25⎥ ⎢ ⎥ ⎢ 23 0 0 0 28 0 36⎥ ⎢ 1 4 9 16 25 36 0 ⎥ ⎣ ⎦
-3-
6.选择造价第五小的序号为 5 的边，即 S 23 ，由于加入后边 S 23 ， S 27 ， S37 将构成回路，因此 舍弃该边 如图所示：
7.选择造价第六小的序号为 6 的边，即 S 47 ，由于加入后边 S34 ， S37 ， S 47 将构成回路，因此 舍弃该边 如图所示：
8.选择造价第七小的序号为 7 的边，即 S 45 ，加入 T 中，此时 T={{6},{ S17 ， S34 ， S 27 ， S37 ，
S 45 ， S16 }}，Cost=34+23=57
如图所示：
11.算法结束 此时，所有顶点已包含在树中，整棵最小生成树已经构造完成。即应该在城市{（1,7） ， （2,7） ， （3,7） ， （3,4） ， （4,5） ， （1,6）}之间建造通信道路，可使得城市间相互通信又造价费 用最小，此时可以得到其最小的费用为 57 万元
-7-
edges[k].end = j; edges[k].weight = G->arc[i][j].weight; k++; } } } sort(edges, G); for (i = 1; i <= G->arcnum; i++) { parent[i] = 0; } printf("最小生成树为:\n"); for (i = 1; i <= G->arcnum; i++)//核心部分 { n = Find(parent, edges[i].begin); m = Find(parent, edges[i].end); if (n != m) { parent[n] = m; printf("< %d, %d > %d\n", edges[i].begin, edges[i].end, edges[i].weight); Mincost+=edges[i].weight; } } printf("使各城市间能够通信的最小费用为：Mincost=%d\n",Mincost); } int Find(int *parent, int f) { while ( parent[f] > 0) { f = parent[f]; } return f; }
Kruskal算法
for(i=0; i<m; i++)
{Байду номын сангаас
parent[i] = -1;
//初始化，先使每个节点各自形成一个单元素集合
}
for(i=1; i<n; i++)
{
x = _find(graph[i].a - 'A');
y = _find(graph[i].b - 'A');
if(x!=y)
//若边的两个顶点不属于同一个集合
酒也。节奏划分思考“山行/六七里”为什么不能划分为“山/行六七里”？
江西)人，因吉州原属庐陵郡，因此他又以“庐陵欧阳修”自居。谥号文忠，世称欧阳文忠公。北宋政治家、文学家、史学家，与韩愈、柳宗元、王安石、苏洵、苏轼、苏辙、曾巩合称“唐宋八大家”。后人又将其与韩愈、柳宗元和苏轼合称“千古文章四大家”。
关于“醉翁”与“六一居士”：初谪滁山，自号醉翁。既老而衰且病，将退休于颍水之上，则又更号六一居士。客有问曰：“六一何谓也？”居士曰：“吾家藏书一万卷，集录三代以来金石遗文一千卷，有琴一张，有棋一局，而常置酒一壶。”客曰：“是为五一尔，奈何？”居士曰：“以吾一翁，老于此五物之间，岂不为六一乎？”写作背景：宋仁宗庆历五年(1045年)，
int find(int x)
int _find(int x) //压缩路径的find（）
{
{
if(parent[x] < 0)
int y,z;
return x;
y = x;
else return find(parent[x]); while(parent[y] >= 0)
}
y = parent[y];
Kruskal算法
1. Kruskal算法(1) 算法思想K r u s k a l算法每次选择n- 1条边，所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。
注意到所选取的边若产生环路则不可能形成一棵生成树。
K r u s k a l算法分e 步，其中e 是网络中边的数目。
按耗费递增的顺序来考虑这e 条边，每次考虑一条边。
当考虑某条边时，若将其加入到已选边的集合中会出现环路，则将其抛弃，否则，将它选入。
初始时没有任何边被选择。
边（ 1 , 6）是最先选入的边，它被加入到欲构建的生成树中，得到图1 3 - 1 2 c。
下一步选择边（ 3，4）并将其加入树中（如图1 3 - 1 2 d所示）。
然后考虑边( 2，7 ，将它加入树中并不会产生环路，于是便得到图1 3 - 1 2 e。
下一步考虑边（ 2，3）并将其加入树中（如图1 3 - 1 2 f所示）。
在其余还未考虑的边中，（7，4）具有最小耗费，因此先考虑它，将它加入正在创建的树中会产生环路，所以将其丢弃。
此后将边（ 5，4）加入树中，得到的树如图13-12g 所示。
下一步考虑边（ 7，5），由于会产生环路，将其丢弃。
最后考虑边（ 6，5）并将其加入树中，产生了一棵生成树，其耗费为9 9。
图1 - 1 3给出了K r u s k a l算法的伪代码。
(2)C代码/* Kruskal.cCopyright (c) 2002, 2006 by ctu_85All Rights Reserved.*//* I am sorry to say that the situation of unconnected graph is not concerned */#include "stdio.h"#define maxver 10#define maxright 100int G[maxver][maxver],record=0,touched[maxver][maxver];int circle=0;int FindCircle(int,int,int,int);int main(){int path[maxver][2],used[maxver][maxver];int i,j,k,t,min=maxright,exsit=0;int v1,v2,num,temp,status=0;restart:printf("Please enter the number of vertex(s) in the graph:\n"); scanf("%d",&num);if(num>maxver||num<0){printf("Error!Please reinput!\n");goto restart;}for(j=0;j<num;j++)for(k=0;k<num;k++){if(j==k){G[j][k]=maxright;used[j][k]=1;touched[j][k]=0;}elseif(j<k){re:printf("Please input the right between vertex %d and vertex %d,if no edge exists please input -1:\n",j+1,k+1);scanf("%d",&temp);if(temp>=maxright||temp<-1){printf("Invalid input!\n");goto re;}if(temp==-1)temp=maxright;G[j][k]=G[k][j]=temp;used[j][k]=used[k][j]=0;touched[j][k]=touched[k][j]=0;}}for(j=0;j<num;j++){path[j][0]=0;path[j][1]=0;}for(j=0;j<num;j++){status=0;for(k=0;k<num;k++)if(G[j][k]<maxright){status=1;break;}if(status==0)break;}for(i=0;i<num-1&&status;i++){for(j=0;j<num;j++)for(k=0;k<num;k++)if(G[j][k]<min&&!used[j][k]){v1=j;v2=k;min=G[j][k];}if(!used[v1][v2]){used[v1][v2]=1;used[v2][v1]=1;touched[v1][v2]=1;touched[v2][v1]=1;path[0]=v1;path[1]=v2;for(t=0;t<record;t++)FindCircle(path[t][0],path[t][0],num,path[t][0]);if(circle){/*if a circle exsits,roll back*/circle=0;i--;exsit=0;touched[v1][v2]=0;touched[v2][v1]=0;min=maxright;}else{record++;min=maxright;}}}if(!status)printf("We cannot deal with it because the graph is not connected!\n"); else{for(i=0;i<num-1;i++)printf("Path %d:vertex %d to vertex %d\n",i+1,path[0]+1,path[1]+1); }return 1;}int FindCircle(int start,int begin,int times,int pre){ /* to judge whether a circle is produced*/int i;for(i=0;i<times;i++)if(touched[begin]==1){if(i==start&&pre!=start){circle=1;return 1;break;}elseif(pre!=i)FindCircle(start,i,times,begin);elsecontinue;}return 1;}。
Kruskal算法
Kruskal 算法构造最小生成树构造赋权图(,,)G V E W =，其中12{,,,}n V v v v = 为顶点集合,其中i v 表示第i 个顶点，12{,,,,}i E e e e = 为边的集合，()ij n n W w ⨯=为邻接矩阵，其中i j i j ij i j v v v v w v v ∈⎧⎪=⎨∞⎪⎩顶点与之间的距离，当（，）E ，与之间没有边时科茹斯克尔（Kruskal ）算法如下： （1）选1e E ∈（E 为边的集合），使得1e 是权重最小的边。
（2）若12,,e i e e …，已选好，则从12{,,e }i E e e -…，中选取1i e +，使得 i ）121{,,e }i e e +…，中无圈，且 ii ）是1i e +是12{,,e }i E e e -…，中权重最小的边。
（3）直到选得1V e - 为止。
(V 是集合V 中元素的个数)例：已知9个村庄之间的两两距离见表5，要架设通讯线路把9个村庄连接起来，求所需要通讯线的最小长度。
表5 10个村庄的两两距离数据（单位：km ）(,,)G V E W =，其中129{,,,}V v v v = 为顶点集合,其中i v 表示第i 个村庄，12{,,,,}i E e e e = 为边的集合，99()ij W w ⨯=为邻接矩阵，其中i j i j ij i j v v v v w v v ∈⎧⎪=⎨∞⎪⎩村庄与之间的距离，当（，）E ，与之间没有通讯路线时科茹斯克尔（Kruskal ）算法如下： （1）选1e E ∈（E 为边的集合），使得1e 是距离最小的边。
（2）若12,,e i e e …，已选好，则从12{,,e }i E e e -…，中选取1i e +，使得 i ）121{,,e }i e e +…，中无圈，且 ii ）是1i e +是12{,,e }i E e e -…，中距离最小的边。
（3）直到选得8e 为止。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.无向网图及边集数组存储示意图
vertex[6]=
2.Kruskal 方法构造最小生成树的过程
(a)一个图 (b)最小生成树过程1
V0 V1 V2 V3 V4 V5
下标 0 1 2 3 4 5 6 7 8 from 1 2 0 2 3 4 0 3 0 to
4
3 5 5 5 5 1
4 2 weight 12
17
19
25
25
26
34
38
46
V1
V0
V4 V5
V2 V3
V1
V0 V5 V2 V3 V4
(c)最小生成树过程2 （d)最小生成树过程3
(e)最小生成树过程4 3.伪代码
1）初始化辅助数组parent[vertexNum];num=0; 2) 依次考查每一条边for(i=0; i<arcNum; i++ ) vex1=edge[i].form 所在生成树的根结点 vex2=edge[i].to 所在生成树的根结点 If(vex1!=vex2)
parent[vex2]=vex1; num++;
if(num==vertexNum-1) 算法结束 4.构造过程中参数变化
顶点集 数组 parent V0 V1 V2 V3 V4 V5
被考查边 输出
说明
初始化
parent -1 -1 -1 -1 -1 -1
6棵生成树，均只有根结点 parent -1 -1 -1 -1 1 -1 (v1,v4)12 (v1,v4)12 vex1=1,vex2=4;parent[4]=1; parent -1 -1 -1 2 1 -1 (v2,v3)17 (v2,v3)17 vex1=2,vex2=3;parent[3]=2; parent -1 -1 -1 2 1 0 (v0,v5)19 (v0,v5)19 vex1=0,vex2=5;parent[5]=0; parent 2 -1 -1 2 1 0 (v2,v5)25 (v2,v5)25 vex1=2,vex2=0;parent[0]=2; parent 2 -1 -1 2 1 0 (v3,v5)25 vex1=2,vex2=2;所在根结点相同 parent 2 -1 1 2 1 0 (v4,v6)26 (v4,v6)26 vex1=1,vex2=2;parent[2]=1; parent 2
-1
1
2
1
生成树根结点是v1
5.主要代码
/**********构造函数************/
template<class DataType>
EdgeGraph<DataType>::EdgeGraph(DataType a[], int n, int e)
{
vertexNum=n; edgeNum=e;
int i,j,weight;
for (int k=0; k<vertexNum; k++)
vertex[k]=a[k];
for (k=0; k<edgeNum; k++)
{
cout<<"输入边依附的两个顶点的编号:";
cin>>i>>j;
edge[k].from=i;
edge[k].to=j;
cout<<"请输入权重：";
cin>>weight;
edge[k].weight=weight;
}
}
/**********Kruskal算法构造最小生成树************/
template <class DataType>
void EdgeGraph<DataType>::Kruskal()
{ int num;
int parent[MaxVertex], vex1, vex2;
for (int i=0; i<vertexNum; i++)
parent[i]=-1;
for (i=0,num=0; i<edgeNum; i++)
{
vex1=FindRoot(parent, edge[i].from);
vex2=FindRoot(parent, edge[i].to);
if (vex1!=vex2)
{
cout << "(" << edge[i].from <<"->"<<edge[i].to << ")" <<"weight: "<< edge[i].weight << endl;
parent[vex2]=vex1;
num++;
if (num==vertexNum-1) return;
}
}
}
/**********寻找根节点************/
template <class DataType>
int EdgeGraph<DataType>::FindRoot(int parent[], int v)
{
int t=v;
while(parent[t] > -1)
t=parent[t];
return t;
}
/**********遍历输出************/
template <class DataType>
void EdgeGraph<DataType>::Print()
{
for (int i=0; i<edgeNum; i++)
{
cout<<"("<<edge[i].from<<"
"<<edge[i].to<<")"<<"weight:"<<edge[i].weight<<endl;;
}
}
6.结果截图
发现不按大小输入weight的值则不能正确生成最小生成树如排好序输入时则得到正确的最小生成树
结果正确，所以需要按大小顺序输入权值大小的Kruskal算法实际上对较复杂无向网图来说不适用。
故思考在程序中添加一个对权值排序的函数(修改对应的from,to)。