最小生成树(Kruskal算法)

Kruskal算法和Prim算法本节所阐述的两种最小生成树算法是上节所介绍的一般算法的细化。

每个算法均采用一特定规则来确定GENERIC-MST算法第3行所描述的安全边；在Kruskal算法中，集合A是一森林，加大集合A中的安全边总是图中连结两不同连通支的最小权边。

在Prim算法中，集合A仅形成单棵树。

添加入集合A的安全边总是连结树与一非树结点的最小权边。

Kruskal算法Kruskal算法是直接基于上一节中给出的一般最小生成树算法的基础之上的。

该算法找出森林中连结任意两棵树的所有边中具有最小权值的边(u,v)作为安全边，并把它添加到正在生长的森林中。

设C1和C2表示边(u,v)连结的两棵树。

因为(u,v)必是连C1和其他某棵树的一条轻边，所以由推论2可知(u,v)对C1是安全边。

Kruskal算法同时也是一种贪心算法，因为算法每一步添加到森林中的边的权值都尽可能小。

Kruskal算法的实现类似于计算连通支的算法。

它使用了分离集合数据结构以保持数个互相分离的元素集合。

每一集合包含当前森林中某个树的结点，操作FIND-SET(u)返回包含u的集合的一个代表元素，因此我们可以通过FIND-SET(v)来确定两结点u和v是否属于同一棵树，通过操作UNION来完成树与树的联结。

MST-KRUSKAL(G,w)1. A←∅2. for 每个结点v V[G]3. do MAKE-SET(v)4. 根据权w的非递减顺序对E的边进行排序5. for 每条边(u,v)∈E，按权的非递减次序6. do if FIND-SET(u) ≠ FIND-SET(v)7. then A←A∪{(u,v)}8. UNION(u,v)9 return AKruskal算法的工作流程如图4所示。

阴影覆盖的边属于正在生成的森林A。

算法按权的大小顺序考察各边。

箭头指向算法每一步所考察到的边。

第1-3行初始化集合A为空集并建立|V|棵树，每裸树包含图的一个结点。

最小生成树的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算法通常被用来解决各种最小生成树的问题，比如公路修建、通信网络的建设、电路板的设计等等。

本文将着重介绍Kruskal算法的原理、步骤和具体应用，以期为读者提供全面的了解和指导。

一、Kruskal算法的原理Kruskal算法是一种基于贪心策略的算法，它通过不断地选择边来构建生成树，直到所有的顶点都被包含在生成树中。

其基本原理可以概括如下：1. 将图中的所有边按权值大小进行排序。

2. 依次从小到大选择边，并检查是否形成环路。

3. 如果没有形成环路，则将该边添加到生成树中。

Kruskal算法的核心思想是“先小后大”，即先选择权值较小的边，直到所有的顶点都被包含在生成树中。

由于Kruskal算法是基于边来构建生成树的，因此它适用于稀疏图和稠密图，而且在实际应用中通常具有较好的效率。

二、Kruskal算法的步骤Kruskal算法的具体步骤可以简单总结为以下几个步骤：1. 初始化：将图中的所有边按权值大小进行排序。

2. 创建一个空的数组T来存储最小生成树的边。

3. 依次从排序后的边集合中选择边e，并检查是否添加e会形成环路。

4. 如果不形成环路，则将边e添加到数组T中。

5. 直到T中包含了n-1条边为止，其中n为顶点的个数。

三、Kruskal算法的具体实现下面我们通过一个简单的示例来说明Kruskal算法的具体实现步骤。

示例：假设有如下的图G和边集合E：顶点集合V：{A, B, C, D, E, F, G, H}边集合E：{(A, B, 4), (A, H, 8), (B, C, 8), (B, H, 11), (C, D, 7), (C, F, 4), (C, I, 2), (D, E, 9), (D, F, 14), (E, F, 10), (F, G, 2), (G, H, 1), (G, I, 6), (H, I, 7)}我们可以按照如下的步骤来求解最小生成树：1. 首先对边集合E进行按权值的排序：(E, F, 2), (G, H, 1), (C, I, 2), (A, B, 4), (C, F, 4), (H, I, 7), (C, D, 7), (D, E, 9), (A, H, 8), (B, C, 8), (G, I, 6), (B, H, 11), (D, F, 14)2. 初始化一个空的数组T来存储最小生成树的边，初始化一个数组parent来记录每个顶点的父节点。

最⼩⽣成树---普⾥姆算法（Prim算法）和克鲁斯卡尔算法（Kruskal算法）最⼩⽣成树的性质：MST性质（假设N=(V,{E})是⼀个连通⽹，U是顶点集V的⼀个⾮空⼦集，如果（u，v）是⼀条具有最⼩权值的边，其中u属于U，v属于V-U，则必定存在⼀颗包含边（u，v）的最⼩⽣成树）普⾥姆算法（Prim算法)思路：以点为⽬标构建最⼩⽣成树1.将初始点顶点u加⼊U中，初始化集合V-U中各顶点到初始顶点u的权值；2.根据最⼩⽣成树的定义：从n个顶点中，找出 n - 1条连线，使得各边权值最⼩。

循环n-1次如下操作：（1）从数组lowcost[k]中找到vk到集合U的最⼩权值边，并从数组arjvex[k] = j中找到该边在集合U中的顶点下标(2)打印此边，并将vk加⼊U中。

（3）通过查找邻接矩阵Vk⾏的各个权值，即vk点到V-U中各顶点的权值，与lowcost的对应值进⾏⽐较，若更⼩则更新lowcost，并将k存⼊arjvex数组中以下图为例#include<bits/stdc++.h>using namespace std;#define MAXVEX 100#define INF 65535typedef char VertexType;typedef int EdgeType;typedef struct {VertexType vexs[MAXVEX];EdgeType arc[MAXVEX][MAXVEX];int numVertexes, numEdges;}MGraph;void CreateMGraph(MGraph *G) {int m, n, w; //vm-vn的权重wscanf("%d %d", &G->numVertexes, &G->numEdges);for(int i = 0; i < G->numVertexes; i++) {getchar();scanf("%c", &G->vexs[i]);}for(int i = 0; i < G->numVertexes; i++) {for(int j = 0; j < G->numVertexes; j++) {if(i == j) G->arc[i][j] = 0;else G->arc[i][j] = INF;}}for(int k = 0; k < G->numEdges; k++) {scanf("%d %d %d", &m, &n, &w);G->arc[m][n] = w;G->arc[n][m] = G->arc[m][n];}}void MiniSpanTree_Prim(MGraph G) {int min, j, k;int arjvex[MAXVEX]; //最⼩边在 U集合中的那个顶点的下标int lowcost[MAXVEX]; // 最⼩边上的权值//初始化,从点 V0开始找最⼩⽣成树Tarjvex[0] = 0; //arjvex[i] = j表⽰ V-U中集合中的 Vi点的最⼩边在U集合中的点为 Vjlowcost[0] = 0; //lowcost[i] = 0表⽰将点Vi纳⼊集合 U ，lowcost[i] = w表⽰ V-U中 Vi点到 U的最⼩权值for(int i = 1; i < G.numVertexes; i++) {lowcost[i] = G.arc[0][i];arjvex[i] = 0;}//根据最⼩⽣成树的定义：从n个顶点中，找出 n - 1条连线，使得各边权值最⼩for(int i = 1; i < G.numVertexes; i++) {min = INF, j = 1, k = 0;//寻找 V-U到 U的最⼩权值minfor(j; j < G.numVertexes; j++) {// lowcost[j] != 0保证顶点在 V-U中，⽤k记录此时的最⼩权值边在 V-U中顶点的下标if(lowcost[j] != 0 && lowcost[j] < min) {min = lowcost[j];k = j;}}}printf("V[%d]-V[%d] weight = %d\n", arjvex[k], k, min);lowcost[k] = 0; //表⽰将Vk纳⼊ U//查找邻接矩阵Vk⾏的各个权值，与lowcost的对应值进⾏⽐较，若更⼩则更新lowcost，并将k存⼊arjvex数组中for(int i = 1; i < G.numVertexes; i++) {if(lowcost[i] != 0 && G.arc[k][i] < lowcost[i]) {lowcost[i] = G.arc[k][i];arjvex[i] = k;}}}int main() {MGraph *G = (MGraph *)malloc(sizeof(MGraph));CreateMGraph(G);MiniSpanTree_Prim(*G);}/*input:4 5abcd0 1 20 2 20 3 71 2 42 3 8output:V[0]-V[1] weight = 2V[0]-V[2] weight = 2V[0]-V[3] weight = 7最⼩总权值: 11*/时间复杂度O(n^2)克鲁斯卡尔算法（Kruskal算法）思路：以边为⽬标进⾏构建最⼩⽣成树在边集中依次寻找最⼩权值边，若构建是不形成环路（利⽤parent数组记录各点的连通分量），则将其添加到最⼩⽣成树中。

用Kruskal算法求无向图的最小生成树该图用邻接矩阵表示，邻接表原理与之相同。

可以指出的是，对于有向图，算法可以做得更加简单，因为对无向图的“回边”情况的处理比有向图回边情况的处理要复杂一些。

图1：输入示例图二：输入时若两点之间没有公共边，则将权值设置为-1。

程序设置处理的最大点数为10。

图三：注意到Kruskal算法的解答结果有时候不是唯一的，这个结果和对图遍历时的顺序有关，但是必需注意的是所有的最小生成树其网络代价和是一样的。

下面是源代码：/* 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[i][0]=v1;path[i][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[i][0]+1,path[i][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][i]==1){if(i==start&&pre!=start){circle=1;return 1;break;}elseif(pre!=i)FindCircle(start,i,times,begin); elsecontinue;}return 1;}。

Kruskal 算法及其应用Kruskal 算法是一种求解最小生成树的算法，其思想是将边按照权值从小到大排序，然后依次将边加入到已构建的生成树中，直到生成树中的边数等于顶点数减一。

Kruskal 算法具有良好的时间复杂度和空间复杂度，因此在实际应用中得到广泛的应用。

本文将介绍 Kruskal 算法的基本思想、证明方法以及其在实际应用中的应用。

下面是本店铺为大家精心编写的4篇《Kruskal 算法及其应用》，供大家借鉴与参考，希望对大家有所帮助。

《Kruskal 算法及其应用》篇1一、Kruskal 算法的基本思想Kruskal 算法是一种求解最小生成树的算法，其基本思想是将边按照权值从小到大排序，然后依次将边加入到已构建的生成树中，直到生成树中的边数等于顶点数减一。

Kruskal 算法的时间复杂度为O(ElogE)，其中 E 表示边的数量。

Kruskal 算法的实现过程可以分为三个步骤：1. 将所有边按照权值从小到大排序；2. 初始化一个空的生成树；3. 依次将排序后的边加入到生成树中，直到生成树中的边数等于顶点数减一。

二、Kruskal 算法的证明方法Kruskal 算法的正确性可以通过证明生成的生成树是最小生成树来证明。

具体来说，可以采用贪心算法的思路，证明 Kruskal 算法得到的生成树是局部最优的，即每次加入的边都是当前状态下的最小边。

证明过程可以分为以下几个步骤：1. 证明 Kruskal 算法得到的生成树是连通的；2. 证明 Kruskal 算法得到的生成树是树结构；3. 证明 Kruskal 算法得到的生成树是最小生成树。

三、Kruskal 算法在实际应用中的应用Kruskal 算法在实际应用中得到广泛的应用，如下：1. 最小生成树：Kruskal 算法可以用于求解最小生成树，将其应用于网络设计、图像处理、生物信息学等领域。

2. 单源最短路径：Kruskal 算法可以用于求解单源最短路径，将其应用于路由算法、图像处理、生物信息学等领域。

Prim算法和Kruskal算法Prim算法和Kruskal算法都能从连通图找出最小生成树。

区别在于Prim算法是挨个找，而Kruskal是先排序再找。

一、Prim算法：Prim算法实现的是找出一个有权重连通图中的最小生成树，即：具有最小权重且连接到所有结点的树。

(强调的是树，树是没有回路的)。

Prim算法是这样来做的：首先以一个结点作为最小生成树的初始结点，然后以迭代的方式找出与最小生成树中各结点权重最小边，并加入到最小生成树中。

加入之后如果产生回路则跳过这条边，选择下一个结点。

当所有结点都加入到最小生成树中之后，就找出了连通图中的最小生成树了。

Prim算法最小生成树查找过程：注意：若候选轻边集中的轻边不止一条，可任选其中的一条扩充到T中。

连通网的最小生成树不一定是惟一的，但它们的权相等。

【例】在上图(e)中，若选取的轻边是(2，4)而不是(2，1)时，则得到如图(h)所示的另一棵MST。

算法特点该算法的特点是当前形成的集合T始终是一棵树。

将T中U和TE分别看作红点和红边集，V-U看作蓝点集。

算法的每一步均是在连接红、蓝点集的紫边中选择一条轻边扩充进T中。

MST性质保证了此边是安全的。

T从任意的根r开始，并逐渐生长直至U=V，即T 包含了C中所有的顶点为止。

MST性质确保此时的T是G的一棵MST。

因为每次添加的边是使树中的权尽可能小，因此这是一种"贪心"的策略。

算法分析该算法的时间复杂度为O(n2)。

与图中边数无关，该算法适合于稠密图。

算法演示：/sjjg/DataStructure/DS/web/flashhtml/prim.htm二、Kruskal算法：Kruskal算法与Prim算法的不同之处在于，Kruskal在找最小生成树结点之前，需要对所有权重边做从小到大排序。

将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。

当所有结点都加入到最小生成树中之后，就找出了最小生成树。

克鲁斯卡尔（Kruskal）算法从另一途径求网的最小生成树。

其基本思想是：假设连通网G=（V，E），令最小生成树的初始状态为只有n个顶点而无边的非连通图T=（V，{}），概述图中每个顶点自成一个连通分量。

在E中选择代价最小的边，若该边依附的顶点分别在T 中不同的连通分量上，则将此边加入到T中；否则，舍去此边而选择下一条代价最小的边。

依此类推，直至T中所有顶点构成一个连通分量为止
克鲁斯卡尔算法思想设计克鲁斯卡尔算法函数主要包括两个部分：首先是带权图G中e条边的权值的排序；其次是判断新选取的边的两个顶点是否属于同一个连通分量。

对带权图G中e条边的权值的排序方法可以有很多种，各自的时间复杂度均不相同，对e条边的权值排序算法时间复杂度较好的算法有快速排序法、堆排序法等，这些排序算法的时间复杂度均可以达到O（elge）。

判断新选取的边的两个顶点是否属于同一个连通分量的问题是一个在最多有n个顶点的生成树中遍历寻找新选取的边的两个顶点是否存在的问题，此算法的时间复杂度最坏情况下为O（n）。

1.无向网图及边集数组存储示意图vertex[6]=2.Kruskal 方法构造最小生成树的过程(a)一个图 (b)最小生成树过程1V0 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 weigh t121719252526343846V1V0V4 V5V2 V3V1V0 V5 V2 V3 V4(c)最小生成树过程2 （d)最小生成树过程3(e)最小生成树过程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 -16棵生成树，均只有根结点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; parent2-1 -1 21(v2,v5)25(v2,v5)25 vex1=2,vex2=0;parent[0]=2;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算法实际上对较复杂无向网图来说不适用。

克鲁斯卡尔算法（Kruskal算法）（最⼩⽣成树算法）-贪⼼克鲁斯卡尔算法：Kruskal算法是⼀种⽤来查找的算法，由Joseph Kruskal在1956年发表。

⽤来解决同样问题的还有和Boruvka算法等。

三种算法都是的应⽤。

和Boruvka算法不同的地⽅是，Kruskal算法在图中存在相同权值的边时也有效。

基本思想：先构造⼀个只含 n 个顶点、⽽边集为空的⼦图，把⼦图中各个顶点看成各棵树上的根结点，之后，从⽹的边集 E 中选取⼀条权值最⼩的边，若该条边的两个顶点分属不同的树，则将其加⼊⼦图，即把两棵树合成⼀棵树，反之，若该条边的两个顶点已落在同⼀棵树上，则不可取，⽽应该取下⼀条权值最⼩的边再试之。

依次类推，直到森林中只有⼀棵树，也即⼦图中含有 n-1 条边为⽌。

发现⼀个好的视频：下图为初始图、只含有点的森林和点与点之间的联系循环找权值最⼩的边依次向下循环...输⼊：6 101 2 61 3 11 4 52 3 52 5 33 4 53 5 63 6 44 6 25 6 6输出：V1-V3=1V4-V6=2V2-V5=3V3-V6=4V5-V6=515代码：#include <iostream>#include <bits/stdc++.h>using namespace std;#define MAX 100int Find(int parent[],int i){while(parent[i]>0){i=parent[i];}return i;}void Kruskal(int u[],int v[],int w[],int n,int m){int parent[MAX];int sum=0;for(int i=1;i<=n;i++) //初始化{parent[i]=0;}int a,b;for(int i=1;i<=m;i++){a=Find(parent,u[i]);b=Find(parent,v[i]);if(a!=b) //a==b说明成环{parent[a]=b;cout<<"V"<<a<<"-"<<"V"<<b<<"="<<w[i]<<endl; sum+=w[i];}}cout<<sum;}int main(){int n,m;int u[MAX],v[MAX],w[MAX];cin>>n>>m;for(int i=1;i<=m;i++){cin>>u[i]>>v[i]>>w[i];}for(int i=1;i<=m;i++) //排序{int min=i;for(int j=i+1;j<=m;j++){if(w[min]>w[j]){min=j;}}swap(u[i],u[min]);swap(v[i],v[min]);swap(w[i],w[min]);}Kruskal(u,v,w,n,m);return0;}。

数学建模最小生成树例题例题1：某城市计划建设一条高速公路，需要在若干个村庄之间选择一条最优路径。

已知各个村庄之间的距离，请使用最小生成树算法为高速公路选择最优路径。

参考答案：最小生成树算法可以用于解决此类问题。

常用的最小生成树算法有Kruskal算法和Prim算法。

1. Kruskal算法：按照边的权重从小到大排序，依次将边加入生成树，如果加入的边与已选择的边不构成环，则加入，否则不加入。

2. Prim算法：首先选择权重最小的边加入生成树，然后从剩余的边中选择一条与已选择的边相连且权重最小的边加入生成树，直到所有边都加入生成树。

例题2：一个通信网络由若干个节点和边组成，节点代表城市，边代表通信线路。

已知各个城市之间的距离和通信需求，请使用最小生成树算法为该通信网络设计一个最优的通信线路网。

参考答案：最小生成树算法可以用于解决此类问题。

通过最小生成树算法，我们可以找到一个包含所有节点且边的总权重最小的树形结构，以满足各个城市之间的通信需求。

常用的最小生成树算法有Kruskal算法和Prim算法。

1. Kruskal算法：按照边的权重从小到大排序，依次将边加入生成树，如果加入的边与已选择的边不构成环，则加入，否则不加入。

2. Prim算法：首先选择权重最小的边加入生成树，然后从剩余的边中选择一条与已选择的边相连且权重最小的边加入生成树，直到所有边都加入生成树。

例题3：一个城市的电力网由多个节点和边组成，节点代表发电厂或变电站，边代表输电线路。

已知各个节点之间的电抗和传输功率，请使用最小生成树算法为该城市电力网设计一个最优的输电线路。

参考答案：最小生成树算法可以用于解决此类问题。

通过最小生成树算法，我们可以找到一个包含所有节点且边的总电抗最小的树形结构，以满足各个节点之间的电力传输需求。

常用的最小生成树算法有Kruskal算法和Prim算法。

1. Kruskal算法：按照边的电抗从小到大排序，依次将边加入生成树，如果加入的边与已选择的边不构成环，则加入，否则不加入。

一、概述在图论中，prim算法和kruskal算法是两种常用的最小生成树算法。

它们分别以不同的方式来寻找给定图的最小生成树，是解决最小生成树问题的有效方法。

本文将重点介绍prim算法和kruskal算法，并通过例题分析，展示它们的应用及原理。

二、prim算法1. prim算法概述2. prim算法步骤3. 例题分析：通过一个具体图示例，展示prim算法的应用过程，详细阐述每一步的操作及思路。

4. prim算法优缺点三、kruskal算法1. kruskal算法概述2. kruskal算法步骤3. 例题分析：通过一个具体图示例，展示kruskal算法的应用过程，详细阐述每一步的操作及思路。

4. kruskal算法优缺点四、prim算法和kruskal算法的比较1. 时间复杂度2. 空间复杂度3. 适用范围4. 其他特点五、例题分析总结通过对两种算法在具体例题中的应用过程分析，总结prim算法和kruskal算法的异同点，以及在实际问题中应用时的考虑因素。

六、结论根据对prim算法和kruskal算法的介绍及例题分析，总结两种算法的特点和应用场景，为不同情况下的最小生成树问题提供参考指导。

七、参考文献列出本文所参考的相关书籍、文献或全球信息站信息，为读者进一步了解prim算法和kruskal算法提供便利。

八、附录可放置示例代码、补充说明或其他相关内容，以便读者更好地理解prim算法和kruskal算法。

由于当前训练模型对于编程题的掌握有一定限制，可以提供在Prim算法和Kruskal算法方面相关的例题解析和应用案例。

以下是一个基于图的例题及其解析。

假设有一个带权重的无向连通图G，图中的顶点集合为V，边的集合为E，每条边的权重由权重函数w(u, v)给出，其中u, v为边的两个顶点。

现在需要使用Prim算法和Kruskal算法来寻找图G的最小生成树。

首先我们需要给出一个具体的图G，如下所示：顶点集合V = {A, B, C, D, E}边的集合E = {(A, B, 3), (A, C, 1), (A, D, 5), (B, C, 4), (B, D, 6), (B, E, 2), (C, D, 7), (C, E, 8), (D, E, 9)}其中，每个元组表示一条边的起始顶点、终止顶点和权重。

数据结构（三⼗三）最⼩⽣成树（Prim、Kruskal） ⼀、最⼩⽣成树的定义 ⼀个连通图的⽣成树是⼀个极⼩的连通⼦图，它含有图中全部的顶点，但只有⾜以构成⼀棵树的n-1条边。

在⼀个⽹的所有⽣成树中，权值总和最⼩的⽣成树称为最⼩代价⽣成树（Minimum Cost Spanning Tree），简称为最⼩⽣成树。

构造最⼩⽣成树的准则有以下3条：只能使⽤该图中的边构造最⼩⽣成树当且仅当使⽤n-1条边来连接图中的n个顶点不能使⽤产⽣回路的边 对⽐两个算法，Kruskal算法主要是针对边来展开，边数少时效率会⾮常⾼，所以对于稀疏图有很⼤的优势；⽽Prim算法对于稠密图，即边数⾮常多的情况会更好⼀些。

⼆、普⾥姆（Prim）算法 1.Prim算法描述 假设N={V,{E}}是连通⽹，TE是N上最⼩⽣成树中边的集合。

算法从U={u0，u0属于V}，TE={}开始。

重复执⾏下⾯的操作：在所有u属于U，v 属于V-U的边(u,v)中找⼀条代价最⼩的边(u0,v0)并加⼊集合TE，同时v0加⼊U，直到U=V为⽌。

此时TE中必有n-1条边，则T=(V,{TE})为N的最⼩⽣成树。

2.Prim算法的C语⾔代码实现/* 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++) /* 循环除下标为0外的全部顶点 */{lowcost[i] = G.arc[0][i]; /* 将v0顶点与之有边的权值存⼊数组 */adjvex[i] = 0; /* 初始化都为v0的下标 */}for(i = 1; i < G.numVertexes; i++){min = INFINITY; /* 初始化最⼩权值为∞， *//* 通常设置为不可能的⼤数字如32767、65535等 */j = 1;k = 0;while(j < G.numVertexes) /* 循环全部顶点 */{if(lowcost[j]!=0 && lowcost[j] < min)/* 如果权值不为0且权值⼩于min */{min = lowcost[j]; /* 则让当前权值成为最⼩值 */k = j; /* 将当前最⼩值的下标存⼊k */}j++;}printf("(%d, %d)\n", adjvex[k], k);/* 打印当前顶点边中权值最⼩的边 */lowcost[k] = 0;/* 将当前顶点的权值设置为0,表⽰此顶点已经完成任务 */for(j = 1; j < G.numVertexes; j++) /* 循环所有顶点 */{if(lowcost[j]!=0 && G.arc[k][j] < lowcost[j]){/* 如果下标为k顶点各边权值⼩于此前这些顶点未被加⼊⽣成树权值 */lowcost[j] = G.arc[k][j];/* 将较⼩的权值存⼊lowcost相应位置 */adjvex[j] = k; /* 将下标为k的顶点存⼊adjvex */}}}}Prim算法 3.Prim算法的Java语⾔代码实现package bigjun.iplab.adjacencyMatrix;/*** 最⼩⽣成树之Prim算法*/public class MiniSpanTree_Prim {int lowCost; // 顶点对应的权值public CloseEdge(Object adjVex, int lowCost) {this.adjVex = adjVex;this.lowCost = lowCost;}}private static int getMinMum(CloseEdge[] closeEdges) {int min = Integer.MAX_VALUE; // 初始化最⼩权值为正⽆穷int v = -1; // 顶点数组下标for (int i = 0; i < closeEdges.length; i++) { // 遍历权值数组，找到最⼩的权值以及对应的顶点数组的下标if (closeEdges[i].lowCost != 0 && closeEdges[i].lowCost < min) {min = closeEdges[i].lowCost;v = i;}}return v;}// Prim算法构造图G的以u为起始点的最⼩⽣成树public static void Prim(AdjacencyMatrixGraphINF G, Object u) throws Exception{// 初始化⼀个⼆维最⼩⽣成树数组minSpanTree，由于最⼩⽣成树的边是n-1，所以数组第⼀个参数是G.getVexNum() - 1，第⼆个参数表⽰边的起点和终点符号，所以是2 Object[][] minSpanTree = new Object[G.getVexNum() - 1][2];int count = 0; // 最⼩⽣成树得到的边的序号// 初始化保存相关顶点和相关顶点间边的权值的数组对象CloseEdge[] closeEdges = new CloseEdge[G.getVexNum()];int k = G.locateVex(u);for (int j = 0; j < G.getVexNum(); j++) {if (j!=k) {closeEdges[j] = new CloseEdge(u, G.getArcs()[k][j]);// 将顶点u到其他各个顶点权值写⼊数组中}}closeEdges[k] = new CloseEdge(u, 0); // 加⼊u到⾃⾝的权值0for (int i = 1; i < G.getVexNum(); i++) { // 注意，这⾥从1开始，k = getMinMum(closeEdges); // 获取u到数组下标为k的顶点的权值最短minSpanTree[count][0] = closeEdges[k].adjVex; // 最⼩⽣成树第⼀个值为uminSpanTree[count][1] = G.getVexs()[k]; // 最⼩⽣成树第⼆个值为k对应的顶点count++;closeEdges[k].lowCost = 0; // 下标为k的顶点不参与最⼩权值的查找了for (int j = 0; j < G.getVexNum(); j++) {if (G.getArcs()[k][j] < closeEdges[j].lowCost) {closeEdges[j] = new CloseEdge(G.getVex(k), G.getArcs()[k][j]);}}}System.out.print("通过Prim算法得到的最⼩⽣成树序列为: {");for (Object[] Tree : minSpanTree) {System.out.print("(" + Tree[0].toString() + "-" + Tree[1].toString() + ")");}System.out.println("}");}} 4.举例说明Prim算法实现过程 以下图为例： 测试类：// ⼿动创建⼀个⽤于测试最⼩⽣成树算法的⽆向⽹public static AdjacencyMatrixGraphINF createUDNByYourHand_ForMiniSpanTree() {Object vexs_UDN[] = {"V0", "V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8"};int arcsNum_UDN = 15;int[][] arcs_UDN = new int[vexs_UDN.length][vexs_UDN.length];for (int i = 0; i < vexs_UDN.length; i++) // 构造⽆向图邻接矩阵for (int j = 0; j < vexs_UDN.length; j++)if (i==j) {arcs_UDN[i][j]=0;} else {arcs_UDN[i][j] = arcs_UDN[i][j] = INFINITY;}arcs_UDN[0][5] = 11;arcs_UDN[1][2] = 18;arcs_UDN[1][6] = 16;arcs_UDN[1][8] = 12;arcs_UDN[2][3] = 22;arcs_UDN[2][8] = 8;arcs_UDN[3][4] = 20;arcs_UDN[3][6] = 24;arcs_UDN[3][7] = 16;arcs_UDN[3][8] = 21;arcs_UDN[4][5] = 26;arcs_UDN[4][7] = 7;arcs_UDN[5][6] = 17;arcs_UDN[6][7] = 19;for (int i = 0; i < vexs_UDN.length; i++) // 构造⽆向图邻接矩阵for (int j = i; j < vexs_UDN.length; j++)arcs_UDN[j][i] = arcs_UDN[i][j];return new AdjMatGraph(GraphKind.UDN, vexs_UDN.length, arcsNum_UDN, vexs_UDN, arcs_UDN);}public static void main(String[] args) throws Exception {AdjMatGraph UDN_Graph = (AdjMatGraph) createUDNByYourHand_ForMiniSpanTree();MiniSpanTree_Prim.Prim(UDN_Graph, "V0");} 输出为：通过Prim算法得到的最⼩⽣成树序列为: {(V0-V1)(V0-V5)(V1-V8)(V8-V2)(V1-V6)(V6-V7)(V7-V4)(V7-V3)} 分析算法执⾏过程：从V0开始：-count为0，k为0，closeEdges数组的-lowCost为{0 10 INF INF INF 11 INF INF INF}，adjVex数组为{V0，V0，V0，V0，V0，V0，V0，V0，V0}-⽐较lowCost，于是k为1，adjVex[1]为V0，minSpanTree[0]为（V0，V1），lowCost为{0 0 INF INF INF 11 INF INF INF}-k为1，与V1的权值⾏⽐较，得到新的-lowCost为：{0 0 18 INF INF 11 16 INF 12}，adjVex数组为{V0，V0，V1，V0，V0，V0，V1，V0，V1}-⽐较lowCost，于是k为5，adjVex[5]为V0，minSpanTree[1]为（V0，V5），lowCost为{0 0 18 INF INF 0 16 INF 12}-k为5，与V5的权值⾏⽐较，得到新的-lowCost为{0 0 18 INF 26 0 16 INF 12}，adjVex数组为{V0，V0，V1，V0，V5，V0，V1，V0，V1}-⽐较lowCost，于是k为8，adjVex[8]为V1，minSpanTree[2]为（V1，V8），lowCost为{0 0 18 INF INF 0 16 INF 0}... 三、克鲁斯卡尔（Kruskal）算法 1.Kruskal算法描述 Kruskal算法是根据边的权值递增的⽅式，依次找出权值最⼩的边建⽴的最⼩⽣成树，并且规定每次新增的边，不能造成⽣成树有回路，直到找到n-1条边为⽌。

Prim算法和Kruskal算法介绍⼀、Prim算法普利姆(Prim)算法适⽤于求解⽆向图中的(Minimum Cost Spanning Tree)。

下⾯是Prim算法构造最⼩⽣成树的过程图解。

选择⼀个节点开始，⽐如V1进⼊集合U，剩下的集合的V-U包括剩下的节点，然后寻找从集合U到集合V-U最近的路径。

这⾥有三条路径分别是权重为6到V2，权重为5到V4以及权重为1到V3，显然到通过V3连接⽽集合U和集合V-U是最近的，选择V3进⼊集合U。

同样继续选择到V-U的路径，此时有6条可选路径，分别是权为6到V2【从V1】，权为5到V4【从V1】，权为5到V2【从V3】，权为5到V4【从V3】，权为6到V5【从V3】，权为4到V6【从V3】。

选择出从V3到V6的路径并将V6添加⾄集合U中。

按照这种⽅法依次将V4，V2和V5添加到集合U直到U和全体节点结合V相等，或者说V-U集合为空时结束，这时选出的n-1条边即为最⼩⽣成树。

⼆、Kruskal算法克鲁斯卡尔(Kruskal)算法是另⼀种求解最⼩⽣成树的算法。

下⾯是Kruskal算法构造最⼩⽣成树的过程图解。

Kruskal则是采取另⼀种思路，即从边⼊⼿。

⾸先n个顶点分别视为n个连通分量，然后选择⼀条权重最⼩的边，如果边的两端分属于两个连通分量，就把这个边加⼊集合E，否则舍去这条边⽽选择下⼀条代价最⼩的边，依次类推，直到所有节点都在同⼀个连通分量上。

三、对⽐假设⽹中有n个节点和e条边，普利姆算法的时间复杂度是O(n^2)，克鲁斯卡尔算法的时间复杂度是O(eloge)，可以看出前者与⽹中的边数⽆关，⽽后者相反。

因此，普利姆算法适⽤于边稠密的⽹络⽽克鲁斯卡尔算法适⽤于求解边稀疏的⽹。