一种新的最小生成树算法
C语言实现最小生成树构造算法
C语⾔实现最⼩⽣成树构造算法最⼩⽣成树最⼩⽣成树（minimum spanning tree）是由n个顶点，n-1条边，将⼀个连通图连接起来，且使权值最⼩的结构。
最⼩⽣成树可以⽤Prim（普⾥姆）算法或kruskal（克鲁斯卡尔）算法求出。
我们将以下⾯的带权连通图为例讲解这两种算法的实现：注：由于测试输⼊数据较多，程序可以采⽤⽂件输⼊Prim（普⾥姆）算法时间复杂度：O（N^2）（N为顶点数）prim算法⼜称“加点法”，⽤于边数较多的带权⽆向连通图⽅法：每次找与之连线权值最⼩的顶点，将该点加⼊最⼩⽣成树集合中注意：相同权值任选其中⼀个即可，但是不允许出现闭合回路的情况。
代码部分通过以下步骤可以得到最⼩⽣成树：1.初始化：lowcost[i]:表⽰以i为终点的边的最⼩权值,当lowcost[i]=0表⽰i点加⼊了MST。
mst[i]:表⽰对应lowcost[i]的起点，当mst[i]=0表⽰起点i加⼊MST。
由于我们规定最开始的顶点是1，所以lowcost[1]=0，MST[1]=0。
即只需要对2~n进⾏初始化即可。
#define MAX 100#define MAXCOST 0x7fffffffint graph[MAX][MAX];void prim(int graph[][MAX], int n){int lowcost[MAX];int mst[MAX];int i, j, min, minid, sum = 0;for (i = 2; i <= n; i++){lowcost[i] = graph[1][i];//lowcost存放顶点1可达点的路径长度mst[i] = 1;//初始化以1位起始点}mst[1] = 0;2.查找最⼩权值及路径更新定义⼀个最⼩权值min和⼀个最⼩顶点ID minid，通过循环查找出min和minid，另外由于规定了某⼀顶点如果被连⼊，则lowcost[i]=0，所以不需要担⼼重复点问题。
Boruvka算法求最小生成树
Boruvka算法求最⼩⽣成树学习了⼀个新的最⼩⽣成树的算法，Boruvka（虽然我不知道怎么读）。
算法思想也是贪⼼，类似于Kruskal。
⼤致是这样的，我们维护图中所有连通块，然后遍历所有的点和边，找到每⼀个连通块和其他连通块相连的最⼩的⼀条边，然后把连通块合并起来，重复这个操作，直到剩下⼀整个连通块，最开始状态是每个点是⼀个单独的连通块。
复杂度是(n+m)longn，因为每次都会合并两个连通块，整个程序进⾏log次操作就会完成，每次操作的复杂度是n+m的。
代码⾮常好理解，我⽤的并查集实现，（然⽽并查集我没有⽤按秩合并，都是细节）。
——by VANE#include<bits/stdc++.h>using namespace std;const int N=5005;const int M=200005;int pre[M<<1],other[M<<1],last[N],l,len[M<<1];int n,m;void add(int x,int y,int z){++l;pre[l]=last[x];last[x]=l;other[l]=y;len[l]=z;}int f[N],mn[2][N];int getfa(int x){return x==f[x]?x:f[x]=getfa(f[x]);}void merge(int x,int y){int fx=getfa(x),fy=getfa(y);f[fx]=fy;}int main(){scanf("%d%d",&n,&m);for(int i=1;i<=n;++i) f[i]=i;for(int i=1;i<=m;++i){int x,y,z;scanf("%d%d%d",&x,&y,&z);add(x,y,z);add(y,x,z);}int ans=0;while(1){memset(mn[0],127,sizeof mn[0]);bool flag=0;for(int i=1;i<=n;++i){for(int p=last[i];p;p=pre[p]){if(getfa(i)!=getfa(other[p]))if(mn[0][getfa(i)]>len[p]){mn[0][getfa(i)]=len[p];mn[1][getfa(i)]=getfa(other[p]);}}}for(int i=1;i<=n;++i){if(mn[0][i]!=mn[0][0]&&getfa(i)!=getfa(mn[1][i])){flag=1;ans+=mn[0][i];merge(i,mn[1][i]);}}if(!flag) break;}for(int i=1;i<n;++i)if(getfa(i)!=getfa(i+1)){puts("orz");return0;}cout<<ans;}。
最小生成树及克鲁斯卡尔算法
最小生成树及克鲁斯卡尔算法
最小生成树是指在一个连通的无向图中，找到一棵生成树，使得所有
边的权值之和最小。
克鲁斯卡尔算法是一种用来求解最小生成树的贪
心算法。
克鲁斯卡尔算法的基本思想是将所有边按照权值从小到大排序，然后
依次加入生成树中，如果加入某条边会形成环，则不加入该边。
直到
生成树中有n-1条边为止，其中n为图中节点的个数。
克鲁斯卡尔算法的时间复杂度为O(ElogE)，其中E为边的数量。
因为需要对所有边进行排序，所以时间复杂度与边的数量有关。
最小生成树的应用非常广泛，例如在网络设计、电力传输、交通规划
等领域都有重要的应用。
在网络设计中，最小生成树可以用来构建网
络拓扑结构，使得网络的总成本最小。
在电力传输中，最小生成树可
以用来确定输电线路的布局，使得电力传输的成本最小。
在交通规划中，最小生成树可以用来确定道路的布局，使得交通运输的成本最小。
除了克鲁斯卡尔算法，还有其他求解最小生成树的算法，例如Prim算法、Boruvka算法等。
这些算法的基本思想都是贪心算法，但具体实
现方式有所不同。
总之，最小生成树是图论中的一个重要问题，克鲁斯卡尔算法是一种常用的求解最小生成树的算法。
在实际应用中，需要根据具体情况选择合适的算法，并结合实际需求进行优化。
求解度约束最小生成树的新的快速算法
ＤＯ ：０３ ７￣ｉ ｎ１０ — ３ １ ０ ８ １ １ 文章编号 ：０ ２ ８ ３ （ ０ ８３ － ０ １０ 文献标识码 ： 中图分类号 ：Ｐ ０ Ｉ １． ８ ．ｓ． ２ ８３ ． ０ ． ． ４ ７ ｓ ０ ２ ３０ １０ — ３ １２ ０ ）１ ０ ５ —２ Ａ Ｔ３１
摘
要： 针对度约束最小生成树 问题 ， 出了一种新的快速算法。 提 新的快速 算法分为两个主要部分 ， 第一部分从 一棵最小生成树 出
发， 构造一棵度约束树。第二部分设计 了一种改进 策略 ， 从第一部分求得的度 约束树 出发 ， 每次去掉树的一条边 ， 将顶 点按照连通 性划分成两个集合 ， 在不违反度约束的情况下 ， 从这两个集合构成的边割 中， 选择 一条权值减少最大的边添加到图中。 通过 大量的
Ｃ ｍ ｕ ｒＥ ｎｅｉ ｎ ｐ ｌ ａｏｓ ｏ ｐ ｔ ， ｅｒ ｇ ａｄ Ａ ｐｉ ｔ ｎ 计算机工０ ８４ ３ ） ４ １
求解 度约束最小 生成树 的新 的快 速算法
王立 东 ， 刘红 卫 ， 陈宏 钦
Ｗ ＡＮＧ Ｌｉ ｄ ｎ ＬＩ － ｏ ｇ， Ｕ Ｈｏ ｇ ｗｅ ， ｎ － ｉ ＣＨＥＮ Ｈｏ ｇ ｉ ｎ —ｑｎ
ｃ ｌ ｔｓｓ ｓ ｏ ｈ ｔ ｔｅ ｎ ｗ ｆ ｓ ａｇ ｒ ｈ ｈ ｓ ｖ ｒ ｏ ｄ ｐ ｒ ｒ ｎ ｅ ａ ｅ ｔ ｈ ｗ ｔ ａ ｈ ｅ ａ ｔ ｌｏ ｔ ｍ ａ ｅｙ ｇ ｏ ｅ ｏ ｍａ ｃ ． ｉ ｆ
Ｋ ｅ ｗｏ ｄｓ： ｄｅ ｅ －ｃ ｎ ｔａｎ ｄ；ｐａ ｎｉｇ ｒ ｅ； ｌｏ ｔｍ ｙ ｒ ｇｒｅ ｏ ｓｒ ｉｅ ｓ ｎ ｎ ｔｅ ａｇ ｒ ｈ ｉ
一种新的求解最小生成树问题的DNA算法
Ｉ Ｎ ０ ９ ３ ４ ＳＳ １ ０ － ０ ４
Ｅ ｍａｌ ｅ ｕ ＠ｃ Ｃ ．ｅ ．ｌ — ｉ ｄ ｆ Ｃ Ｃｎ ｔ １ ： ｅ
Ｃ ｍ ｕ ｒ ｎ ｗｅ ｇ ｎ ｅ ｈ ｏ ｇ ｏ ｐ ｔ Ｋ ｏ ｌ ｅａ ｄ Ｔ ｃ ｎ ｌ ｙ电脑 知识 与技术 ｅ ｄ ｏ
ｈ ｔ ：ｗ ． ｎ ｓｎ ｔ ａ ｔ ／ ｗｗ ｄ ｚ ．ｅ ． ｐ／ ｃ
经解 决 很 多 的 Ｎ Ｐ完 全 问题 ， 在 图 论 中对 图的 最 小生 成 树 问题 （ Ｔ ） 但 ＭＳ Ｐ 的研 究 不 是 很 多 ， 文设 计 了一 种 Ｄ Ａ 计算 模 型 来 解 决 这 本 Ｎ 个 问 题 ， 其在 编 码 的策 略 上 给 出 了一 些创 新 的思路 。 尤
计 算 智 能 是 当今 国际 上 迅 速发 展 的前 沿 交 叉 学科 ． 是模 拟 人 的智 能 行 为 来 进 行 计 算 ， 于解 决 不 确 定 、 它 对 非线 性 、 杂 的 各 类 复、 问题 ， 有 非 常广 阔的 应用 前 景 。 其 自从 Ａ ｌ ｎ 出 Ｄ Ａ计算 模 型 以来【 更 加 拓 展 了计 算 智 能 的研究 领域 。 Ｎ 计算 是 一 种 具 尤 ｄｅ ｍａ 提 Ｎ 】 １ ， ＤＡ 以 Ｄ Ａ链 与 相关 的某 些生 物 酶 等作 为 最 基 本 材 料 的 、 于 某些 生 化 反 应 原 理 的一 种 新 型 的 分 子 生物 计 算 方 法 。利 用 Ｄ Ａ计 算 已 Ｎ 基 Ｎ
prim算法c语言
prim算法c语言什么是Prim算法？Prim算法，也叫普里姆算法，是一种用于求解最小生成树的贪心算法。
最小生成树是指在一个无向连通图中，连接所有节点且边权值之和最小的树。
Prim算法的基本思想是从一个起始节点开始，每次选择与当前已经构建好的部分形成的子图相连的、权值最小的边所连接的节点，并将该节点加入到已经构建好的部分中。
直到所有节点都被加入到已经构建好的部分中，此时得到了一棵最小生成树。
Prim算法步骤1. 选定一个起点作为已经构建好的部分。
2. 将与该起点相连且未被访问过的边加入到候选集合中。
3. 从候选集合中选择一条权值最小的边连接到未被访问过的节点，并将该节点加入到已经构建好的部分中。
4. 将新加入节点所连接且未被访问过的边加入到候选集合中。
5. 重复步骤3和步骤4，直至所有节点都被加入到已经构建好的部分中。
Prim算法C语言实现下面给出Prim算法C语言实现代码：```#include <stdio.h>#include <stdlib.h>#include <limits.h>#define MAX_VERTICES 100#define INF INT_MAXtypedef struct {int weight;int visited;} Vertex;typedef struct {int vertices[MAX_VERTICES][MAX_VERTICES]; int num_vertices;} Graph;void init_graph(Graph *graph, int num_vertices) {graph->num_vertices = num_vertices;for (int i = 0; i < num_vertices; i++) {for (int j = 0; j < num_vertices; j++) {graph->vertices[i][j] = INF;}}}void add_edge(Graph *graph, int u, int v, int weight) { graph->vertices[u][v] = weight;graph->vertices[v][u] = weight;}void prim(Graph *graph) {Vertex vertices[MAX_VERTICES];for (int i = 0; i < graph->num_vertices; i++) {vertices[i].weight = INF;vertices[i].visited = 0;}vertices[0].weight = 0;for (int i = 0; i < graph->num_vertices - 1; i++) {// 找到未访问过的权值最小的节点int min_vertex_index = -1;for (int j = 0; j < graph->num_vertices; j++) {if (!vertices[j].visited && (min_vertex_index == -1 || vertices[j].weight < vertices[min_vertex_index].weight)) { min_vertex_index = j;}}// 将该节点标记为已访问vertices[min_vertex_index].visited = 1;// 更新与该节点相连的未访问过的节点的权值for (int j = 0; j < graph->num_vertices; j++) {if (!vertices[j].visited && graph->vertices[min_vertex_index][j] < vertices[j].weight) {vertices[j].weight = graph->vertices[min_vertex_index][j];}}}// 输出最小生成树printf("Minimum Spanning Tree:\n");for (int i = 1; i < graph->num_vertices; i++) {printf("%d - %d (%d)\n", i, (i - 1), vertices[i].weight); }}int main() {Graph graph;init_graph(&graph, 6);add_edge(&graph, 0, 1, 6);add_edge(&graph, 0, 2, 1);add_edge(&graph, 0, 3, 5);add_edge(&graph, 1, 4, 3);add_edge(&graph, 2, 4, 5);add_edge(&graph, 2, 3, 5);add_edge(&graph, 2, 5, 4);add_edge(&graph, 3 ,5 ,2);prim(&graph);return EXIT_SUCCESS;}```代码解释- 定义了Vertex结构体，用于存储节点的权值和访问状态。
最小生成树的模型数学公式
最小生成树的模型数学公式
最小生成树的模型数学公式是：
给定无向连通图G(V,E)，其中V为图的顶点集合，E为图的边集合。
每条边e∈E都带有一个非负权重w(e)。
找到一个包含图中所有顶点的子图T(V,E')，使得E' ⊆ E，并且E'构成一颗树（即连通且无环），使得所有的边的权重之和最小。
拓展：
最小生成树的应用十分广泛，可以用于解决多种问题。
以下是最小生成树的一些常见拓展场景：
1.带有约束条件的最小生成树：
在某些情况下，除了最小化权重之和外，还需要满足一些特定的约束条件。
例如，可以要求最小生成树的边数限制在特定的范围内，或者要求选择特定类型的边。
这时可以在最小生成树的模型中引入额外的约束条件，从而得到满足要求的最小生成树。
2.多目标最小生成树：
有时候，最小生成树问题不仅需要最小化权重之和，还需要考虑其他目标。
例如，可以同时考虑最小化权重之和和最大化生成树中的最长边权重。
这样的问题可以转化为多目标优化问题，并通过权衡不同目标之间的关系来求解。
3.带有边权重动态变化的最小生成树：
在某些场景中，图的边权重可能会根据一些规则进行动态变化。
例如，网络中的通信链路可能会根据网络拓扑和负载情况进行变化。
这时可以通过动态更新最小生成树来快速适应环境变化，从而保持最小生成树的有效性。
总之，最小生成树的模型可以通过引入不同的约束条件和目标函数进行拓展，以适应不同的应用场景。
最小生成树的算法
最小生成树的算法王洁引言：求连通图的最小生成树是数据结构中讨论的一个重要问题．在现实生活中，经常遇到如何得到连通图的最小生成树，求最小生成树不仅是图论的基本问题之一 ,在实际工作中也有很重要的意义，,人们总想寻找最经济的方法将一个终端集合通过某种方式将其连接起来 ,比如将多个城市连为公路网络 ,要设计最短的公路路线;为了解决若干居民点供水问题 ,要设计最短的自来水管路线等.而避开这些问题的实际意义 ,抓住它们的数学本质 ,就表现为最小生成树的构造。
下面将介绍几种最小生成树的算法。
一，用“破圈法”求全部最小生成树的算法1 理论根据1.1 约化原则给定一无向连通图 G =（V ,E ）（ V 表示顶点，E 表示边），其中 V={ 1v , 2v ,3v …… n v },E= { 1e , 2e , 3e …… n e }对于 G 中的每条边 e ∈ E 都赋予权ω（i e ）>0，求生成树 T = （V ,H ），H ⊆ E ，使生成树所有边权最小，此生成树称为最小生成树．（1） 基本回路将属于生成树 T 中的边称为树枝，树枝数为n -1，不属于生成树的边称为连枝．将任一连枝加到生成树上后都会形成一条回路．把这种回路称为基本回路，记为()cf e 。
基本回路是由 T 中的树枝和一条连枝构成的回路．（2） 基本割集设无向图 G 的割集 S （割集是把连通图分成两个分离部分的最少支路集合） ，若 S 中仅包含有T 中的一条树枝，则称此割集为基本割集，记为()S e 。
基本割集是集合中的元素只有一条是树枝，其他的为连枝．（3） 等长变换设T=(V,H),为一棵生成树，e ∈ H, 'e ∈ E, 'e ∉ H,当且仅当'e ∈()cf e ，也就是说e ∈()S e ，则'T =T ⊕{e, 'e }也是一棵生成树。
当()e ω='()e ω时，这棵生成树叫做等长变换。
最小生成树
如此进行下去，每次往生成树里并入一 个顶点和一条边，直到n-1次后，把所有 n 个顶点都并入生成树T的顶点集U中， 此时U=V，TE中包含有（n-1）条边；
图
图6.10 图G 及其生成树
无向连通图 G 图
➢ 生成树
图6.10 图G 及其生成树
生成树
➢ 最小生成树
图
1.1 普里姆(prim)算法
假设G=(V,E)是一个具有n 个顶点的连通网络， T=(U,TE)是G的最小生成树，其中U是T的顶点 集，TE是T的边集，U和TE的初值均为空。
算法开始时，首先从V中任取一个顶点（假定 为V1），将此顶点并入U中，此时最小生成树 顶点集U={V1}；
这样，T就是最后得到的最小生成树。
普里姆算法中每次选取的边两端，总是 一个已连通顶点（在U集合内）和一个未 连通顶点（在U集合外），故这个边选取 后一定能将未连通顶点连通而又保证不 会形成环路。
图
图6.11 普里姆算法例子
图
为了便于在顶点集合U和V-U之间选择权 最小的边，建立两个数组closest和 lowcost,closest[i]表示U中的一个顶点，该 顶点与V-U中的一个顶点构成的边具有最 小的权；lowcost表示该边对应的权值。
姆
{
算
min=lowcost[j];
法
k=j;
续
} printf(“(%d,%d)”,k,closest[j]);
/* 打印生成树的一条边*/
一种基于二进制编码的最小生成树算法
ｂｒ ｆｈ ｒｐ ｄ ｅ ｅ ｅｇａｈｅｇ ．Ｗｈ ｔｓ ｏｅ ｉｅｉ ｎｔｓ ｏ ｆｈ ｏ — ａｎｎ ｅ ｒｕ ｈｔｅ ｕ ｇｍｅｔ ｆ ｅ ｒｐ ｏｔ ａ ｒ ， ｌ ａ ｍｅ ｅｎ ｎｓ ｎ ｉｇｔ ｅ ｈｏｇ ｄ ｅ ｎ ａ ｈ ｉｍ ｔ ｍ ｅ ｓ ｏｔ ｉ ｐ ｒ ｔ ｈ ｊ ｏｔ ｇ ｈ
ｃ ａ ａ ｔ ｒｓｉｓｏ ｅ ｍｉ ｍｕ ｓ ｎｎｎｇｔｅ ｈ ｒ ｃｅ ｔ ｆｔ ｎｉ ｍ ｐａ ｉ ｒ ｅ．Ａｔｆｒｔ ｉ ｅｉ ｎ ｔ ｓｓ ｍｅ ｏ ｅ ｎ ｎ ｓ ｎｎ ｎ ｒ ｅ ｔ ｒ ｕ ｈ ｔ ｅ ｎ ｍ— ｉ ｃ ｈ ｓ ，ｔ ｌｍｉ ａｅ ｏ ｆｔ ｏ －ｐａ ｉ ｇｔｅ ｈ ｏ ｇ ｕ ｉ ｈ ｈ
ｃ ｅ ｔｐ ｌａ ｓｅ ｓ，ｃ ｎｖ ｎ ｅ ｔｐ ｏ ｒ ｍ ｍｐ ｅ ｎａ ｉｎ，ｇ ｎ ｒ ｏ ｄ ｃ ａ ａ ｔ ｒｓ ｃ ｒ ｏ ｅ ｉｎ ｒ ｇ ａ ｉ ｌ ｍｅ ｔｔｏ ｅ ｅａ ｇ ｏ ｈ ｒｃｅ ｔ ． ｌ ｉｉ
Ｋｅ ｒ ｓ：ｍ ｎ ｍｕ ｓ ａ ｎ ｎ ｅ ｙ ｗｏ ｄ ｉ ｉ ｍ ｐ ｎ ｉ ｇ ｔ ｅ；ｃ ｎ ｅ ｔ ｄ ｇ ａ ｈ；ｂ ｎ ｒ ｏ ｅ；ｃ ｒ ｍｏ ｏ ； ｇ ｒ ｈ ｒ ｏ ｎ ｃｅ ｒ ｐ ｉ ａｙ ｃ ｄ ｈ ｏ ｓ ｍｅ ａ ｏ ｔ ｍ ｌ ｉ
Ｄ Ｉ１．９ ９ｊｉ ｎ １０ － ８ ．０ ２０ ． １ Ｏ ： ３６ ／．ｓ ． ０９ ８ １２ １ ．１００ ０ ｓ ４
一
种基 于 二 进 制 编码 的最 小生 成 树 算 法
王 防修
（ 武汉工业学 院 数学与计算机 学院 ， 湖北 武汉 ４０２ ） ３０３
摘
要 ：针 对 目前 的 最 小生成树 算 法 只 能 求一 个 最 小 生成 树 问题 ， 出一种 新 的 最 小 生成树 提
最小生成树（普里姆算法）
最⼩⽣成树（普⾥姆算法）：所谓⽣成树，就是n个点之间连成n-1条边的图形。
⽽最⼩⽣成树，就是权值（两点间直线的值）之和的最⼩值。
⾸先，要⽤⼆维数组记录点和权值。
如上图所⽰⽆向图：int map[7][7];map[1][2]=map[2][1]=4;map[1][3]=map[3][1]=2;......然后再求最⼩⽣成树。
具体⽅法是：1.先选取⼀个点作起始点，然后选择它邻近的权值最⼩的点（如果有多个与其相连的相同最⼩权值的点，随便选取⼀个）。
如1作为起点。
visited[1]=1;pos=1;//⽤low[]数组不断刷新最⼩权值，low[i](0<i<=点数)的值为：i点到邻近点（未被标记）的最⼩距离。
low[1]=0; //起始点i到邻近点的最⼩距离为0low[2]=map[pos][2]=4;low[3]=map[pos][3]=2;low[4]==map[pos][4]=3;low[5]=map[pos][5]=MaxInt; //⽆法直达low[6]=map[pos][6]=MaxInt;2.再在伸延的点找与它邻近的两者权值最⼩的点。
//low[]以3作当前位置进⾏更新visited[3]=1;pos=3;low[1]=0; //已标记，不更新low[2]=map[1][2]=4; //⽐5⼩，不更新low[3]=2; //已标记，不更新low[4]=map[1][4]=3; //⽐1⼤，更新后为：low[4]=map[3][4]=1;low[5]=map[1][5]=MaxInt;//⽆法直达，不更新low[6]=map[1][6]=MaxInt;//⽐2⼤，更新后为：low[6]=map[3][6]=2;3.如此类推...当所有点都连同后，结果最⽣成树如上图所⽰。
所有权值相加就是最⼩⽣成树，其值为2+1+2+4+3=12。
⾄于具体代码如何实现，现在结合POJ1258例题解释。
一种新的最小生成树算法_徐建军
第39卷第14期电力系统保护与控制Vol.39 No.14 2011年7月16日Power System Protection and Control July 16, 2011一种新的最小生成树算法徐建军1,2，沙力妮1，张 艳1，张登峰3，刘广成3,许爱华1，李宏玉1（1.东北石油大学电气信息工程学院，黑龙江 大庆 163318；2.哈尔滨工业大学电气工程及自动化学院，黑龙江 哈尔滨 150001；3.大庆油田电力集团，黑龙江 大庆 163000)摘要：针对在最小生成树求解中常用的Prim算法和Kruskal算法适合直接在图上作业而不适于计算机求解，提出了一种新的最小生成树算法：根据最小生成树的定义和性质，对权矩阵进行操作。
其优点是：求解过程简单清晰，形象直观，快速有效，易于编程，且具有更广泛的适用性，在求解多节点网络的最小生成树时更能体现其计算速度快的优越性。
最后用大庆油田电网作为具体的实例验证了本算法的正确性。
关键词：最小生成树；Prim算法；Kruskal算法；权矩阵；大庆油田电网A new algorithm for minimum spanning treeXU Jian-jun1,2，SHA Li-ni1，ZHANG Yan1，ZHANG Deng-feng3，LIU Guang-cheng3, XU Ai-hua1, LI Hong-yu1（1.Department of Electrical and Information Engineering，Northeast Petroleum University，Daqing 163318，China；2. Department of Electrical Engineering，Harbin Institute of Technology，Harbin 150001，China；3. Daqing Oil Field Power Group，Daqing 163000，China）Abstract：Prim and Kruskal algorithms of minimum spanning tree commonly used in solving minimum spanning tree are more suitable for working directly on the map but not suitable for computer solving．Aiming at that, this paper presents a new minimum spanning tree algorithm．According to the definition and nature of the minimum spanning tree the weight matrix， is operated The．advantages are that the solving process is simple and clear vivid fast and effective,，， easy to program and it has a broader，applicability When solving．the minimum spanning tree with multi-node network, the superiority of its calculation speed can be better reflected Finally Daqing oil field power is．，taken as a specific instance to verify the validity of the algorithm.Key words：minimum spanning tree；Prim algorithm；Kruskal algorithm；weight matrix；Daqing oil field power中图分类号： TM744 文献标识码：A 文章编号： 1674-3415(2011)14-0107-060 引言最小生成树的应用相当广泛，其中一个典型应用就是基于最小生成树算法的网架规划[1-2]。
数据结构之最小生成树Prim算法
数据结构之最⼩⽣成树Prim算法普⾥姆算法介绍 普⾥姆（Prim）算法，是⽤来求加权连通图的最⼩⽣成树算法 基本思想：对于图G⽽⾔，V是所有顶点的集合；现在，设置两个新的集合U和T，其中U⽤于存放G的最⼩⽣成树中的顶点，T存放G的最⼩⽣成树中的边。
从所有uЄU，vЄ(V-U) (V-U表⽰出去U的所有顶点)的边中选取权值最⼩的边(u, v)，将顶点v加⼊集合U中，将边(u, v)加⼊集合T中，如此不断重复，直到U=V为⽌，最⼩⽣成树构造完毕，这时集合T中包含了最⼩⽣成树中的所有边。
代码实现1. 思想逻辑 （1）以⽆向图的某个顶点（A）出发，计算所有点到该点的权重值，若⽆连接取最⼤权重值#define INF (~(0x1<<31)) （2）找到与该顶点最⼩权重值的顶点（B），再以B为顶点计算所有点到改点的权重值，依次更新之前的权重值，注意权重值为0或⼩于当前权重值的不更新，因为1是⼀当找到最⼩权重值的顶点时，将权重值设为了0，2是会出现⽆连接的情况。
（3）将上述过程⼀次循环，并得到最⼩⽣成树。
2. Prim算法// Prim最⼩⽣成树void Prim(int nStart){int i = 0;int nIndex=0; // prim最⼩树的索引，即prims数组的索引char cPrims[MAX]; // prim最⼩树的结果数组int weights[MAX]; // 顶点间边的权值cPrims[nIndex++] = m_mVexs[nStart].data;// 初始化"顶点的权值数组"，// 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
for (i = 0; i < m_nVexNum; i++){weights[i] = GetWeight(nStart, i);}for (i = 0; i < m_nVexNum; i ++){if (nStart == i){continue;}int min = INF;int nMinWeightIndex = 0;for (int k = 0; k < m_nVexNum; k ++){if (weights[k]!= 0 && weights[k] < min){min = weights[k];nMinWeightIndex = k;}}// 找到下⼀个最⼩权重值索引cPrims[nIndex++] = m_mVexs[nMinWeightIndex].data;// 以找到的顶点更新其他点到该点的权重值weights[nMinWeightIndex]=0;int nNewWeight = 0;for (int ii = 0; ii < m_nVexNum; ii++){nNewWeight = GetWeight(nMinWeightIndex, ii);// 该位置需要特别注意if (0 != weights[ii] && weights[ii] > nNewWeight){weights[ii] = nNewWeight;}}for (i = 1; i < nIndex; i ++){int min = INF;int nVexsIndex = GetVIndex(cPrims[i]);for (int kk = 0; kk < i; kk ++){int nNextVexsIndex = GetVIndex(cPrims[kk]);int nWeight = GetWeight(nVexsIndex, nNextVexsIndex);if (nWeight < min){min = nWeight;}}nSum += min;}// 打印最⼩⽣成树cout << "PRIM(" << m_mVexs[nStart].data <<")=" << nSum << ": ";for (i = 0; i < nIndex; i++)cout << cPrims[i] << "";cout << endl;}3. 全部实现#include "stdio.h"#include <iostream>using namespace std;#define MAX 100#define INF (~(0x1<<31)) // 最⼤值(即0X7FFFFFFF)class EData{public:EData(char start, char end, int weight) : nStart(start), nEnd(end), nWeight(weight){} char nStart;char nEnd;int nWeight;};// 边struct ENode{int nVindex; // 该边所指的顶点的位置int nWeight; // 边的权重ENode *pNext; // 指向下⼀个边的指针};struct VNode{char data; // 顶点信息ENode *pFirstEdge; // 指向第⼀条依附该顶点的边};// ⽆向邻接表class listUDG{public:listUDG(){};listUDG(char *vexs, int vlen, EData **pEData, int elen){m_nVexNum = vlen;m_nEdgNum = elen;// 初始化"邻接表"的顶点for (int i = 0; i < vlen; i ++){m_mVexs[i].data = vexs[i];m_mVexs[i].pFirstEdge = NULL;}char c1,c2;int p1,p2;ENode *node1, *node2;// 初始化"邻接表"的边for (int j = 0; j < elen; j ++){// 读取边的起始顶点和结束顶点p1 = GetVIndex(c1);p2 = GetVIndex(c2);node1 = new ENode();node1->nVindex = p2;node1->nWeight = pEData[j]->nWeight;if (m_mVexs[p1].pFirstEdge == NULL){m_mVexs[p1].pFirstEdge = node1;}else{LinkLast(m_mVexs[p1].pFirstEdge, node1);}node2 = new ENode();node2->nVindex = p1;node2->nWeight = pEData[j]->nWeight;if (m_mVexs[p2].pFirstEdge == NULL){m_mVexs[p2].pFirstEdge = node2;}else{LinkLast(m_mVexs[p2].pFirstEdge, node2);}}}~listUDG(){ENode *pENode = NULL;ENode *pTemp = NULL;for (int i = 0; i < m_nVexNum; i ++){pENode = m_mVexs[i].pFirstEdge;if (pENode != NULL){pTemp = pENode;pENode = pENode->pNext;delete pTemp;}delete pENode;}}void PrintUDG(){ENode *pTempNode = NULL;cout << "邻接⽆向表:" << endl;for (int i = 0; i < m_nVexNum; i ++){cout << "顶点:" << GetVIndex(m_mVexs[i].data)<< "-" << m_mVexs[i].data<< "->"; pTempNode = m_mVexs[i].pFirstEdge;while (pTempNode){cout <<pTempNode->nVindex << "->";pTempNode = pTempNode->pNext;}cout << endl;}}// Prim最⼩⽣成树void Prim(int nStart){int i = 0;int nIndex=0; // prim最⼩树的索引，即prims数组的索引char cPrims[MAX]; // prim最⼩树的结果数组int weights[MAX]; // 顶点间边的权值cPrims[nIndex++] = m_mVexs[nStart].data;// 初始化"顶点的权值数组"，// 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
生成最小生成树的方法
生成最小生成树的方法
生成最小生成树的方法有以下几种：
1. Kruskal算法：该算法首先将图中的边按权值从小到大排序，然后依次考虑每条边，若加入该边不会形成环，则将该边加入最小生成树中，直到最小生成树的边数等于节点数减一为止。
2. Prim算法：该算法从任意一个节点开始，不断选择与当前
最小生成树相连的边中权值最小的边，将其加入最小生成树中，直到所有节点都被加入最小生成树为止。
3. Boruvka算法：该算法首先将图中的每个节点作为一个独立
的连通分量，并初始化一个空的最小生成树。
然后，依次遍历所有连通分量，每次选择与该连通分量相连的最小权值边，并将其加入最小生成树中。
当最小生成树中的边数等于节点数减一时，算法停止。
4. Reverse-Delete算法：该算法从图中的所有边中按权值从大
到小的顺序考虑，然后依次删除每条边，若删除该边后原图仍然是连通的，则继续删除下一条边，直到最小生成树的边数等于节点数减一为止。
这些方法都可以用来生成最小生成树，选择哪种方法取决于具体的应用场景和图的特点。
设计一个用破圈法求最小生成树的算法
设计一个用破圈法求最小生成树的算法
破圈法是一种求解最小生成树的算法，它基于Prim算法，用于求解最小生成
树（Minimum Spanning Tree， MST）问题。
破圈法同样也能解决切分图中（Cutting）边缘权重最小化的问题，是一种创建适应性结构的方法。
破圈法的原理可以理解为迭代式的选择最小边界的策略，其包括核心算法思想：
1. 首先计算图中的26未访问节点的最小边权重。
2. 然后添加最小权重边，将最小权重边连接的两个点打破圈。
3. 重复步骤1，其中只考虑不在圈中的节点的最小边权重，直至无节点可添加，完成最小生成树的构建。
破圈法具有稳定、高效和低内存占用特点。
它类似于Prim算法，但是它比
Prim算法更快，因为它节省了比较步骤，即只考虑不在圈中的节点的最小边权重。
破圈法可广泛用于互联网开发中的多种应用，比如路由器的简化、家庭网络构建、通信系统构建以及计算机科学和生物信息学中的最短路径问题等。
其优越性是，在构建复杂、动态网络中，能够准确地表示相互联系，加快了最短路径检索的过程；而且，它由于不需要建立额外的树结构，因此内存消耗比较小。
破圈法是最小生成树问题的一种很好的解决方案，它能够有效地避免圈死现象，构建一个没有重复的树或图；它的实现思路也比较简单，可以用来解决复杂网络中的最短路径问题。
最小生成树算法的应用
最小生成树算法的应用最小生成树算法是图论中重要的算法之一，其可用于解决许多实际问题。
在无向连通图中，最小生成树指的是图中所有边的集合，使得连接所有节点的代价最小。
最小生成树算法主要有Prim算法和Kruskal算法两种，本文将探讨这两种算法的应用。
一、Prim算法及其应用Prim算法是一种基于贪心思想的最小生成树算法，它将整个图分为两个集合：已经包含在最小生成树内的节点集合和未包含在最小生成树内的节点集合。
算法开始时，已经包含在最小生成树内的节点集合为空，未包含节点集合包含整个图。
随着算法的进行，两个集合中的节点不断互相转移，直至最小生成树形成为止。
以下是Prim算法的基本步骤：1. 从任意一个节点开始，将其加入已包含节点集合中。
2. 对于已包含节点集合中的所有节点，找出它们与未包含节点集合中节点的边中权值最小的那条，将与之相连的节点加入已包含节点集合中。
3. 重复步骤2，直至最小生成树形成。
Prim算法的时间复杂度为O(N^2)，其中N为图中节点数。
因此，Prim算法适用于节点数量较少的图。
Prim算法有许多实际应用，其中之一是在计算机网络中实现路由协议。
在网络中，每一个节点都需要选择一个和自己相连的节点作为下一步传递数据的目标。
为了避免重复传输或者丢失数据包，路由协议需要保证每一个数据包能够找到最短的传输路径，同时尽可能地避免网络拥塞。
Prim算法恰好能够解决这个问题，它能够由网络中的节点生成一颗树，树上的每个节点都能够连接网络中所有的节点，同时保证整个连接过程中的最短路径。
因此，Prim算法成为计算机网络中重要的算法之一。
二、Kruskal算法及其应用Kruskal算法也是一种基于贪心思想的最小生成树算法，它将整个图先看做是一个节点的集合，然后不断地将边加入其中，形成最小生成树。
Kruskal算法的基本步骤如下：1. 将图中所有边按照权值从小到大排序。
2. 依次遍历所有的边，在加入当前边时，判断当前边的两个节点是否在同一个集合中，如果不在同一个集合中，就将它们合并，并将这条边加入最小生成树的边集中。
一种新的基于最小生成树的物流配送优化路线算法
并 建 立 优 化 转 移 策略 ， 发 由最 少生 成 树 构 造 最 小 生 成 树 的 算 法 ， 过 对 最 小 生 成 树 进 行 标 记 的 方 法 最 后 开 通
得 到 最 优 路 径 ， 物 流 配 送 的周 转 总量 最 小 。 算 法 用 Ｊｕｌｅ ９开 发 ， 行 表 明 所 提 出的 算 法是 有 效 的 ， 化 使 ｂｉ ｒ ｄ 运 简
生产率 以外 的 重 要 利 润 源 泉 … 因 此 研 究 在 现 有 １，
Ｐ ｏ ｌ 。本文 研究 的 车辆 路径 问题 （ Ｐ ， ｒｂ ｍ） ｅ ＶＲ ） 最早 由 Ｇ． ａ ｔｉ ２在 １ ５ Ｄ ｎｚ ￣Ｊ ９ ９年 首先 提 出 ， ｇ 问题 可归 纳 为
在配 送 中心 、 客户 位置 和需 求 以及 道路 网络 已知 的
一
种 新 的 基 于 最 小 生 成 树 的 物 流 配 送 优 化 路 线 算 法
杨 跃 武
（ 山科 学 技 术 学 院 机 电与 信 息 工 程 学 院 ， 东 佛 山 ５ ８ ０ ） 佛 广 ２ ０ ０
摘
要 ： 出一 种 基 于树 理 论 算 法 的物 流 配送 线路 优 化 决 策 ， 先 将 复 杂 的 道 路 网 转 化 成 最 少 生 成 树 提 首
（ Ｐ ＶＲ ）
Ｐｏ ｌ ＶＲ ） ｒｂ ｍ Ｐ 和库 存 控 制 问题 （ ｎ ｅ ｔｒ ｏ ｔ ｌ ｅ Ｉｖｎｏｙ Ｃ ｎｒ ｏ
１ 引 言
现代 物 流 作 为 一 种先 进 的组 织方 式 和 管 理技 术 ， 广泛认 为是 企 业 在 降 低 物 资 消耗 、 高 劳动 被 提
Ａｂ ｔａ ｔ Ａｎ ｏ ｔ ｚ ｄ ｓｒ ｔ ｇ ｓ ｐ ｏ ｏ ｅ Ｏ ｉ ｖ ｓ ｉ ａｅ ｈ ｅ ｉｌ ｒ ｕ ｉｇ ｐ ｏ ｌｍｓ ｓ ｒ ｃ ： ｐ ｉ ｅ ｔ ａｅ ｙ ｉ ｒ ｐ ｓ ｄ ｔ ｎ ｅ ｔ ｔｄ ｔ ｅ ｖ ｈ ｃｅ ｏ ｔ ｒ ｂ ｅ ．Ｗ ｅ ｂ ｉ ｅ ｅ ａ ｄ ｓ ｒｉ ｎ ｏ ｈ ｍｉ ｇ ｎ ｕ ｌ ｈ ｒ ｅｃ ｔ ｆｔ ｅ ｄ ｏ ｒ ｕ ｉｇ ｎ ｔｗｉｈ ｍｉ ｉ ｍ ｐ ｎ ｉ ｇ ｔｅ ｓａ ｄ ｄ ｃ ｉｎ ｔ ｅ ｒ ｈ ｔ ｅ ｎ ａ ｅ ｔａ ｐ ｏ ｃ ｏ ｔ ｅ ｔ ｎ ｍｕ ｓ ａ ｎｎ ｒ ｅ ｎ ｅ ｉ ｏ Ｏ ｓ ａ ｃ ｈ ｅ ｒ ｓ ｐ ｒ ａ ｈ．Ａｎ ａｇ ｒ ｈ ｉ ｄ ｖ ｌｐ ｄ ｔ ｂ ａｎ ｍｉ ｎ ｓ ｌｏ ｉ ｍ ｓ ｅ ｅｏ ｅ ｏ ｏ ｔ ｉ ｎ— ｔ
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一种新的最小生成树算法姓名：金鸿轩班级：软件13-6学号：132001062015-01-18一种新的最小生成树算法作者：金鸿轩辽宁工程技术大学软件学院，辽宁省葫芦岛市，125105摘要：本文提出一种新的算法以完成加权连通图的最小生成树(minimum spanning tree,MST)。
该算法具有以下优点：1，由于主要以排序为主，因此比较简单。
2，算法复杂度与Boruvka 和Prim（PFS，堆）算法是同一个数量级，在图的密度小于1 的情况下，提出的算法比Boruvka 和Prim（PFS，堆）算法性能优越。
3，即使在大型图中，内存不能一次读入全部数据，提出的算法在Step2 中只需扫描一次数据库就能完成，对系统要求较低。
关键词：最小生成树；边顺生长；边逆生长；算法复杂度A new minimum spanning tree algorithmThis paper presents a new algorithm to complete the weighted minimum spanning tree of connected graph，The algorithm has the following advantages ：1，Because mainly the sorting, so simple 2The algorithm complexity and Boruvka and Prim (PFS, heap) algorithm is the same order of magnitude, the density of the diagram under the condition of less than 1, put forward to calculateMethod than Boruvka and Prim algorithm (PFS, heap) superior performance.3Even in a large figure, memory cannot be read at a time All the data, the algorithm in Step2 scan a database, will be finished on the system requirements is lowClosing date of draft ：2015.1.19Author's brief introduction ：jinhongxuanCommunication contacts ：985441540@1. 引言对于一个随机加权无向图，寻找其最小生成树的问题有许多重要的应用，而且解决此问题的算法至少从1920 年就已经出现。
然而，研究人员仍在寻求更好的方法。
因为这个问题并没有到完全的理解[1] 。
经典的MST 算法其实现的效率大相径庭，这些算法（例如：Boruvka、Prim 算法等）在做运算时大都要求一次将数据读入内存中以做比较，如果处理的是大型图，内存没办法在一次就把所有的数据读入时，这些算法将受到一定局限性（虽然也有一些片外排序的技术，但其实现也不容易）。
针对这个问题，本文提出一种新的算法以实现在无向连通图中寻找最小生成树，基于分治法[2] 的思想，将主要的排序分为两部分，在每部分中的子运算只需求读入内存很少的数据以做比较，而在算法复杂度和Boruvka 和Prim（PFS，堆）算法为同一数量级，若图的密度小于1 的话，本文提出的算法比Boruvka 和Prim（PFS，堆）算法还更优。
本文安排如下：在第二节中对Boruvka, Prim 算法及本文算法进行了介绍；第三节对文章给出的一个推论做了证明；在第四节中对算法的开销进行了推导并给出该算法的一个示例。
第五节对算法进行了评估并对全文进行了总结。
2. 算法简介2.1. Boruvka 算法Boruvka 算法由Boruvka 于1926 年提出（早于图论产生）。
该算法为每个分量设置’leade 用DFS 在m 时间内求出；在每次运算中检查每条边一次以修正各分量的安全边权；第i 次迭代每个分量大小至少为2i ；最多log V 次迭代，总O(E log V )。
以下是该算法的伪代码：2.2 Prim 算法该算法由Prim 提出，但事实上Jarnik 于1930 年更早提出。
算法通过一系列不断扩张的子树来构造一棵最小生成树。
它从图的顶点集中任意选择一个单顶点作为序列中的初始子树，然后每次加入该子树的安全边。
下面是该算法的伪代码：2.3 本文提出算法输入：加权流通图 G＝<V,E>，i j V V 表示i V 到j V 的边，i j e . 表示i V 到j V 的边上的权输出：T E ，图G最小生成树的边集合Step1: 在每一个节点上寻找与之连接的最小边，这样会形成K 棵树的森林，这些边的集合为1E ，第 K棵树用该棵树的点集合表示{ | }K K K V V V i i∈，⎥⎦⎥⎢⎣≤≤⎢ 21 k VStep2: 在Step1 中没有被选中的边的集合{ E - 1 E }中，去掉森林中每一个树中的这些边{( , ) | ( , ) { }, } 1 E V V V V E E i j c Ki K j Ki K j= ∈−≠。
然后在剩余的边集合{ E - 1 E - c E }寻找最的k-1 条边，用集合2 E 表示Step3：输出ET ，T 1 2 E = E ∪E3.一个推论的证明该推论相推论：在加权流通图中选择一个节点与之连接的权重最小的边所形成的集合是森林。
当于在形成过程中其每一个元素都是树。
即等价于所选择的这些边中不会形成回路。
3.1、两个定义：定义1：K 个节点，K V ,V , ,V 1 2 L ,其形成边是按 1 2 k V →V →L→V 称为“边顺生长(forward growth edge)”；如果其形成边是按k V1 ←V2 ←L←V 称为“边逆生长(backwardgrowth edge)”。
定义 2：定义图G的密度为： ( ) (V V )f G E2 ⋅log=3.2、两个子推论：子推论1：边顺生长的权重是逐渐变小，边逆生长的权重是逐渐变大的。
子推论2：同一个节点与之相连最多只有一条边是顺生长的，而可以有多条边逆生长。
由定义得两个子推论显然成立。
3.3、证明（采用归纳法证明）3.3.1考虑当K＝3 时，节点1 V ，2 V ， 3 V ，设1 V 最小的邻接边是1 V 2 V ， 2 V节点有两种情况：(a) 2 V 是边顺生长到3 V 和(b) 2 V 是边逆生长到3 V 。
（1）、在(a)中，假设如果3 V 能边顺生长一条边到1 V ，形成环，则由子推论1 得1,2 2,3 3,1 e > e > e ，与 1,2 e 是1 V 与之连接的权重最小的边相矛盾，所以假设不成立。
假设如果3 V 能边逆生长一条边到1 V ，也即1 V 边顺生长到3 V （ 1 V 3 V ），由子推论2 得，1 V 已经是一次边顺生长（ 1 V 2 V ），所以1 V 上不会边顺生长到3 V 形成环。
即在(a)中不会形成环。
（2）、在(b)中，由子推论2 知，节点1 V 、3 V 已不能再从这两个节点顺生长出边来，不会再生成1 V 3 V 边而形成环。
综（1）（2）所述当K＝3 时不会形成环，即生成的边是树。
3.3.2、当K>3 时，考虑节点1 V ， 2 V ， 3 V ，…，K V（1）、若边的形成是按 1 2 −1 →→→K V V L V 边顺生长，则按 3.3.1 中（1）的结论知，无论K−1 V 是边顺生长到K V 还是K−1 V 是边逆生长到K V 都不会使K V 出现边1 V K V 而形成环。
（2）、若边的形成使按i V1 →V2 →L→V （1<i<K-1）边顺生长，节点i V 是按边逆生长到i+1 V ，相当于i+1 V 是边顺生长到i V ，则由子推论 2 显然得i i k V ←V ←←V +1 +2 L 只能按边逆生长。
这样就形成了3.3.1 中（b）问题，由3.3.1 中（2）结论得不会生成1 V K V 边而形成环。
综（1）（2）所述当K>3 时不会形成环，即生成的边是树。
由3.3.1、3.3.2 得推论成立。
证毕。
4. 算法的开销：4.1、在Step1 中的开销在 Step1 结束时，若图中有K（⎥⎥⎢⎣≤≤⎢21 k V ）棵树，则选出的边为 V-K 条。
令第 i 个节点有i x 条邻边，则选出这 V-K条边需要比较的次数有(2E −V)次：x E V x EViVii 1 2 , 21 1Σ因为Σ＝= =− = −。
4.2、在Step2 中的开销在 Step2 中，最坏情况下 = Φ C E 为空集，即需要在剩余E-(V-K)条边中选出K-1 条，按一般逐个比较需要Σ−=−−−1( )KE V K i 次，采用快速排序一类需要[ ( )]2 [E − (V −K)]log E−V −K 次。
下面介绍本文采用的方法：先从 E-(V-K) 挑出 K-1 条边，其权为e i K i , = 1,2,L ，将这将这 K-1 条边权值排序，{ , 1, 2, } i e = e i = L K ， { } max , 1,2, i e = e i = L K余下的（E-V-1）条边的权为e , j = 1,2, E −V −1 jfor {j=1; j<(E-V-1); j++}If j e < max ei j e←e i = K − e + e max { , 1,2,L }endReturn e最后集合e 中所保留的边就是需要选出的最后K-1 条边。
在该步中需要做2 (E −V −1) log K−次运算。
将Step1、 Step2 中选的边做并集就是该图的最小生成树，共需要运算的次数为：( 1) ( 1) 222222(2 ) ( 1) log (2 ) ( 1) log( )loglog ( log )VKVVE V E V E V E VE E VE EV− + − + −≤−+ −+ −≈ + −= + − (4.1)注意到算法开销中（4.1）式的第二项，及当f (G) >1时，算法的运算次数会略增加。
图中(a)为一个无向加权连通图及其该图的MST，左边为该图各边的权重，其中颜色加深部分为对应的MST 边的权值。
图(b)为本文法中的Step1：在每个顶点找出与该顶点连接权最小的边，形成森林，得到1 E ；图(c)为算法中的Step2：在Step1 中没有被选中的边的集合{ E - 1 E }中，去掉森林中每一个树中c E 。