最小生成树(Prim、Kruskal算法)整理版
MST最小生成树的Kruskal和Prim算法
1.实验目的（结出本次实验所涉及并要求掌握的知识点）最小生成树kruskal算法和prim算法的实现2.实验内容（结出实验内容具体描述）最小生成树kruskal算法和prim算法的实现3.算法描述及实验步骤（用适当的形式表达算法设计思想与算法实现步骤）数据结构：（MST也是图，所以实现用了邻接表表示）void union_v(LinkGraph*g,int index,int j){edgenode*p=g->adjlist[index].firstedge;g->adjlist[index].state=j;while(p){if(g->adjlist[p->adjvex].state!=j)union_v(g,p->adjvex,j);p=p->next;}}//（加边）对边按权排升序，每次考虑最小边，判断他两端是否是不同集合，是就把这边unionedges* Kruskal_MST(LinkGraph*g,int c){edges*head=creatEdgeList(g);edges*p;edgenode*s;int i,j;//判断每一条边，是否需要unionprintf("排序后的边结点：\n");p=head->next;while(p){printf("%d %d %d",p->leftv,p->rightv,p->weigth);printf("\n");p=p->next;}p=head->next;for(i=0;i<g->n;i++){g->adjlist[i].state=i;// 初始化点集，每个点都位于不同的连通分量}while(p){if(g->adjlist[p->leftv].state!=g->adjlist[p->rightv].state){// 只要这条边可以加入MST，就创建图结点// 把这些边当成图结点，创建图（MST树）p->flag=1;i=p->leftv;j=p->rightv;s=(edgenode *)malloc(sizeof(edgenode));s->adjvex=j;s->weigth=p->weigth;s->next=g->adjlist[i].firstedge; // 头插法创建邻接表g->adjlist[i].firstedge=s;if (c==0) { // c=0表示无向图s=(edgenode *)malloc(sizeof(edgenode));s->adjvex=i;s->next=g->adjlist[j].firstedge;g->adjlist[j].firstedge=s;}// union操作int m=g->adjlist[i].state;int n=g->adjlist[j].state;if(m<n){g->adjlist[j].state=m;union_v(g,j,m);}else{g->adjlist[i].state=n;}}p=p->next;}// 返回边结点链表return head;}Prim算法的实现：edges* Prim_MST(LinkGraph*g,int c){edges*head=creatEdgeList(g);edges*p;edgenode*s;int i,j;printf("排序后的边结点：\n");p=head->next;while(p){printf("%d %d %d",p->leftv,p->rightv,p->weigth);printf("\n");p=p->next;}for(i=0;i<g->n;i++){g->adjlist[i].state=0;// 初始化点集，所有点未在MST中}//从head的第一条边的顶点出发，逐个寻找需要union的int count=0;//用来记录目前MST中有多少个点p=head->next;g->adjlist[p->leftv].state=1;//选中第一个点加入count++;int l,r;while(count!=g->n){p=head->next;while(p){l=g->adjlist[p->leftv].state;r=g->adjlist[p->rightv].state;// 只有l，r一个在点集，一个不在点集，才unionif(l+r == 1){if(l*r==0){p->flag=1;count++;// 建MST树/图j=p->rightv;s=(edgenode *)malloc(sizeof(edgenode));s->adjvex=j;s->weigth=p->weigth;s->next=g->adjlist[i].firstedge; // 头插法创建邻接表g->adjlist[i].firstedge=s;if (c==0) { // c=0表示无向图s=(edgenode *)malloc(sizeof(edgenode));s->adjvex=i;s->next=g->adjlist[j].firstedge;g->adjlist[j].firstedge=s;}// union操作if(l==0)g->adjlist[p->leftv].state=1;else if (r==0)g->adjlist[p->rightv].state=1;break;}else{p=p->next;}}else{p=p->next;}}}// 返回边结点链表return head;}4.调试过程及运行结果（详细记录在调试过程中出现的问题及解决方法。
的最小生成树算法Prim与Kruskal算法的比较
的最小生成树算法Prim与Kruskal算法的比较Prim算法和Kruskal算法都是常用的最小生成树算法，它们可以在给定的加权连通图中找到连接所有节点的最小权重边集合。
然而，这两种算法在实现细节和时间复杂度上有所不同。
本文将对Prim算法和Kruskal算法进行比较，并讨论它们的优缺点以及适用场景。
一、Prim算法Prim算法是一种贪心算法，它从一个起始节点开始，逐步扩展最小生成树的边集合，直到包含所有节点为止。
具体步骤如下：1. 选取一个起始节点作为最小生成树的根节点。
2. 在最小生成树的边集合中寻找与当前树集合相连的最小权重边，并将这条边添加到最小生成树中。
3. 将新添加的节点加入到树集合中。
4. 重复步骤2和3，直到最小生成树包含所有节点为止。
Prim算法的时间复杂度为O(V^2)，其中V是节点的个数。
这是因为在每轮迭代中，需要从树集合以外的节点中找到与树集合相连的最小权重边，而在最坏情况下，可能需要检查所有的边。
二、Kruskal算法Kruskal算法是一种基于边的贪心算法，它按照边的权重从小到大的顺序依次选择边，并判断是否加入最小生成树中。
具体步骤如下：1. 初始化一个空的最小生成树。
2. 将所有边按照权重从小到大进行排序。
3. 依次检查每条边，如果这条边连接了两个不同的树（即不会形成环），则将这条边加入到最小生成树中。
4. 重复步骤3，直到最小生成树包含所有节点为止。
Kruskal算法使用并查集数据结构来快速判断连通性，时间复杂度为O(ElogE)，其中E是边的个数。
排序边的时间复杂度为O(ElogE)，而对每条边进行判断和合并操作的时间复杂度为O(E)。
三、比较与总结1. 时间复杂度：Prim算法的时间复杂度为O(V^2)，而Kruskal算法的时间复杂度为O(ElogE)。
因此，在边的数量较大的情况下，Kruskal 算法的效率优于Prim算法。
2. 空间复杂度：Prim算法需要维护一个大小为V的优先队列和一个大小为V的布尔数组，而Kruskal算法需要维护一个大小为V的并查集。
最小生成树的Prim算法以及Kruskal算法的证明
最⼩⽣成树的Prim算法以及Kruskal算法的证明Prime算法的思路：从任何⼀个顶点开始，将这个顶点作为最⼩⽣成树的⼦树，通过逐步为该⼦树添加边直到所有的顶点都在树中为⽌。
其中添加边的策略是每次选择外界到该⼦树的最短的边添加到树中（前提是⽆回路）。
Prime算法的正确性证明：引理1：对于连通图中的顶点vi，与它相连的所有边中的最短边⼀定是属于最⼩⽣成树的。
引理2：证明：假设最⼩⽣成树已经建成；(vi, vj)是连接到顶点vi的最短边，在最⼩⽣成树中取出vi，断开连接到vi的边，则⽣成树被拆分成1、顶点vi2、顶点vj所在的连通分量（单独⼀个顶点也看作⼀个独⽴的连通分量）3、其余若⼲个连通分量（个数⼤于等于0）三个部分现在要重建⽣成树，就要重新连接之前被断开的各边虽然不知道之前被断开的都是哪⼏条边，但是可以通过这样⼀个简单的策略来重建连接：将vi分别以最⼩的成本逐个连接到这若⼲个互相分离的连通分量；具体来说，就是要分别遍历顶点vi到某个连通分量中的所有顶点的连接，然后选择其中最短的边来连接vi和该连通分量；⽽要将vi连接到vj所在的连通分量，显然通过边(vi, vj)连接的成本最低，所以边(vi, vj)必然属于最⼩⽣成树（如果连接到vi的最短边不⽌⼀条，只要任意挑选其中的⼀条(vi, vj)即可，以上的证明对于这种情况同样适⽤）。
这样我们就为原来只有⼀个顶点vi的⼦树添加了⼀个新的顶点vj及新边(vi, vj)；接下来只要将这棵新⼦树作为⼀个连通⼦图，并且⽤这个连通⼦图替换顶点vi重复以上的分析，迭代地为⼦树逐个地添加新顶点和新边即可。
Kruskal算法：通过从⼩到⼤遍历边集，每次尝试为最⼩⽣成树加⼊当前最短的边，加⼊成功的条件是该边不会在当前已构建的图中造成回路，当加⼊的边的数⽬达到n-1，遍历结束。
Kruskal算法的正确性证明：Kruskal算法每次为当前的图添加⼀条不会造成回路的新边，其本质是逐步地连接当前彼此分散的各个连通分量（单个顶点也算作⼀个连通分量），⽽连接的策略是每次只⽤最⼩的成本连接任意两个连通分量。
最小生成树---普里姆算法（Prim算法）和克鲁斯卡尔算法（Kruskal算法）
最⼩⽣成树---普⾥姆算法（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数组记录各点的连通分量），则将其添加到最⼩⽣成树中。
最小生成树（MST）Prim算法和Kruskal算法
最⼩⽣成树（MST）Prim算法和Kruskal算法刚学完最⼩⽣成树，赶紧写写学习的⼼得（其实是怕我⾃⼰忘了）最⼩⽣成树概念:⼀个有 n 个结点的的⽣成树是原图的极⼩连通⼦图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。
就是说如果我们想把⼀张有n个点的图连接起来，那我们就只需要n-1条边（原因显然：就如同⼀条有n个点的线段，他们之间最少需要n-1条边连起来）最⼩⽣成树就是寻找值最⼩的这n-1个点，把他们加和。
⾸先，最⼩⽣成树最基本的算法是Prim和Kruskal算法Prim算法：算法分析&思想讲解：Prim算法采⽤“蓝⽩点”思想：⽩点代表已经进⼊最⼩⽣成树的点，蓝点代表未进⼊最⼩⽣成树的点。
Prim算法每次循环都将⼀个蓝点u变为⽩点，并且此蓝点u与⽩点相连的最⼩边权min[u]还是当前所有蓝点中最⼩的。
这样相当于向⽣成树中添加了n-1次最⼩的边，最后得到的⼀定是最⼩⽣成树。
Prim算法的好处就在于它与边⽆关，主要⽤于稠密图，复杂度为O（n^2），实⽤度不如Kruskal算法⾼代码介绍：（好像不可以直接⽤，有点问题）#include<iostream>#include<cstring>#include<cstdio>using namespace std;const int MAXN=5010;int t[MAXN][MAXN];bool b[MAXN];int MIN[MAXN];int main(){memset(b,false,sizeof(b));memset(t,127,sizeof(t));memset(MIN,127,sizeof(MIN)); //把每⼀条未赋值的边赋为较⼤的⼀个数int n,m;int ans=0;scanf("%d",&n);for(int i=1;i<=n;i++)t[i][i]=0;for(int i=1;i<=n;i++){ //邻接矩阵存图for (int j=1;j<=n;j++){ //不同问题存图⽅式不同cin>>t[i][j];}}MIN[1]=0;//先找点：for(int i=1;i<=n;i++){int x=0; //x为0 就是说⼀开始是从⼀个虚拟点开始的然后我们找与它相邻的边并且还没被找过的点for(int j=1;j<=n;j++){if(!b[j]&&MIN[j]<MIN[x]){ //我们以这⼀个点开始寻找与它相邻的最⼩的边x=j; //然后就标记这个点以便于接着⽤这个点继续往下找}}b[x]=true; //找完这个点后就变成⽩点，表⽰已找过//再扩边：for(int j=1;j<=n;j++){if(!b[j]&&MIN[j]>t[x][j]){ //这段代码就是给我们刚找到的X点的邻边赋实际值，这样在下次寻找X的最⼩边时就可以找到啦MIN[j]=t[x][j]; //所以说找点的代码就⽐较好理解了}}}for(int i=1;i<=n;i++){ans+=MIN[i];//求最⼩和}cout<<ans<<endl;return0;}知识扩展：本算法在移动通信、智能交通、移动物流、⽣产调度等物联⽹相关领域都有⼗分现实的意义，采⽤好的算法，就能节省成本提⾼效率。
最小生成树算法总结
最小生成树算法总结最小生成树是指在一个无向连通图中，找到一个子树，使得这棵子树中所有边的权值之和最小。
最小生成树可以用于最优化问题，例如道路铺设、网络布线等。
下面将介绍三种最小生成树算法：Prim算法、Kruskal算法、Boruvka算法。
1. Prim算法Prim算法是一种贪心算法，从一个点开始，每次添加连接到已有集合中的最小边，直到所有点都在同一个集合中。
可以用以下步骤描述Prim算法：(1) 选择一个起点，将该起点加入最小生成树的顶点集合，然后将该顶点相邻的边加入边集合中。
(2) 从边集合中找到权值最小的一条边，将该边对应的顶点加入最小生成树的顶点集合，同时将该顶点相邻的边加入边集合中。
(3) 重复上述步骤，直到所有顶点都在最小生成树的顶点集合中。
Prim算法的实现可以使用堆优化，时间复杂度为O(E + VlogV)，其中E为边数，V为顶点数。
2. Kruskal算法Kruskal算法也是一种贪心算法，与Prim算法不同的是，Kruskal算法是按照边的权值从小到大依次添加，直到所有顶点都在同一个集合中。
可以用以下步骤描述Kruskal算法：(1) 将所有边按照权值从小到大排序。
(2) 依次取出排好序的边，如果该边所连接的两个顶点不在同一个集合中，就将这条边加入最小生成树的边集合中，并将这两个顶点合并到同一个集合中。
(3) 重复步骤(2)，直到所有顶点都在同一个集合中。
Kruskal算法的实现可以使用并查集，时间复杂度为O(ElogE)，其中E为边数。
3. Boruvka算法Boruvka算法是一种基于集合的分治算法，与Prim算法和Kruskal算法不同，Boruvka算法的时间复杂度是线性的。
可以用以下步骤描述Boruvka算法：(1) 对每个顶点建立单元素集合。
(2) 对每个集合，选择与该集合相连的最小权值的边，将这些边添加到最小生成树的边集合中，并将这些集合合并到同一个集合中。
(3) 如果只剩下一个集合，算法结束。
求无向图的最小生成树算法——Prim与Kruskal
1.算法思想
对于图G=(V,E)，用Prim算法求最小生成树T=(S,TE)的流程如下
① 初始化：设S、TE为空集，任选节点K加入S。
② 选取一条权值最小的边（X,Y），其中X∈S，且not (Y∈S） 即，选取一条权值最小的、连接着S中一点与S外一点的边。
以上操作重复|V|-1次结束。由于每次加入S的点i都在当时取到了符合流程②的边min{lowcost}，而lowcost[i]=w(i,closest[i])，所以此时的最小生成树的各边就是(i,closest[i])，i∈V且not (i=x)【需要注意的是出发点x的closest[x]还是x，所以应忽略，实际取到x-1条边】。把i从1取到|V|，便得到最小生成树T的每条边。
为了比较快速地选边，我们用两个数组lowcost、closest动态地维护每一个点到S的最短距离。在某一状态下，lowcost[i]表示所有与i相连且另一端点在S中的边中的权值最小值，closest[i]表示在S中且与i相连的点中与i之间距离最小的点。显然，lowcost[i]=w(i,closest[i])。需要注意的是两个数组记录的都是边而不是路径。若i没有边直接连向S，则lowcost[i]=∞。另外，若i已在S中，则lowcost[i]=0。
lowcost[j] = w[k][j];
closest[j] = k;
} //由新加入S中的k点使某些点到S的距离缩短，所以更新各点的lowcost和close= 1; i <= n; i++)
if(i != closest[i]){
设出发点为x。初始时对于任意k∈V，closest[k]=x，lowcost[k]=w（k,x）【w（i，j）表示i、j间的距离。初始化时，若两点间没有边则w（i，j）赋为一个足够大的整数（如maxint），并且所有点到自身的距离赋为0，即w（i，i）=0】
分别利用prim算法和kruskal算法实现求图的最小生成树
/*分别利用prim算法和kruskal算法实现求图的最小生成树*/ #include<stdio.h>#include<stdlib.h>#define MaxVertexNum 12#define MaxEdgeNum 20#define MaxValue 1000typedef int Vertextype;typedef int adjmatrix[MaxVertexNum][MaxVertexNum]; typedef Vertextype vexlist[MaxVertexNum];int visited[MaxVertexNum]={0};struct edgeElem{int fromvex;int endvex;int weight;};typedef struct edgeElem edgeset[MaxVertexNum];void Creat_adjmatrix(vexlist GV,adjmatrix GA,int n,int e) {int i,j,k,w;printf("输入%d个顶点数据",n);for(i=0;i<n;i++)scanf("%d",&GV[i]);for(i=0;i<n;i++)for(j=0;j<n;j++)if(i==j) GA[i][j]=0;else GA[i][j]=MaxValue;printf("输入%d条无向带权边",e);for(k=0;k<e;k++){scanf("%d%d%d",&i,&j,&w);GA[i][j]=GA[j][i]=w;}}void Creat_edgeset(vexlist GV,edgeset GE,int n,int e) {int i,j,k,w;printf("输入%d个顶点数据",n);for(i=0;i<n;i++)scanf("%d",&GV[i]);printf("输入%d条无向带权边",e);for(k=0;k<e;k++){ scanf("%d%d%d",&i,&j,&w);GE[k].fromvex=i;GE[k].endvex=j;GE[k].weight=w;}}void output_edgeset(edgeset GE,int e){int k;for(k=0;k<e;k++)printf("%d %d %d,",GE[k].fromvex,GE[k].endvex,GE[k].weight); printf("\n");}void prim(adjmatrix GA,edgeset CT,int a,int n){int i,j,t,k,w,min,m;struct edgeElem x;for(i=0;i<n;i++)if(i<a){CT[i].fromvex=a;CT[i].endvex=i;CT[i].weight=GA[a][i];}else if(i>a){CT[i-1].fromvex=a;CT[i-1].endvex=i;CT[i-1].weight=GA[a][i];}for(k=1;k<n;k++){min=MaxValue;m=k-1;for(j=k-1;j<n-1;j++)if(CT[j].weight<min){min=CT[j].weight;m=j;}x=CT[k-1];CT[k-1]=CT[m];CT[m]=x;j=CT[k-1].endvex;for(i=k;i<n-1;i++){t=CT[i].endvex;w=GA[j][t];if(w<CT[i].weight){CT[i].weight=w;CT[i].fromvex=j;}}}}void kruskal(edgeset GE,edgeset C,int n){ int i,j,k,d;int m1,m2;adjmatrix s;for(i=0;i<n;i++){for(j=0;j<n;j++)if(i==j) s[i][j]=1;else s[i][j]=0;}k=1;d=0;while(k<n){for(i=0;i<n;i++){if(s[i][GE[d].fromvex]==1) m1=i;if(s[i][GE[d].endvex]==1) m2=i;}if(m1!=m2){C[k-1]=GE[d];k++;for(j=0;j<n;j++){s[m1][j]=s[m1][j]||s[m2][j];s[m2][j]=0;}}d++;}}void main(){int n,e;vexlist GV;adjmatrix GA;edgeset GE,C;printf("输入图的顶点数和边数：");scanf("%d%d",&n,&e);Creat_adjmatrix( GV, GA, n, e);printf("利用prim算法从0点出发求图的最小生成树：\n");prim(GA,GE,0,n);output_edgeset( GE, n-1);printf("输入图的顶点数和边数:");scanf("%d%d",&n,&e);Creat_edgeset( GV,GE,n, e);printf("利用kruskal算法从0点出发求图的最小生成树：\n");kruskal( GE, C, n);output_edgeset( C, n-1);}最小生成树（prim算法和kruskal算法）收藏最小生成树（prim算法）用最小生成树的解决的经典问题：若要在n个城市间建设通信网路，给出任意两个城市的距离和每米通信网路的造价，问怎样设计网络可以使网路的造价最小。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、树及生成树的基本概念树是无向图的特殊情况，即对于一个N个节点的无向图，其中只有N-1条边，且图中任意两点间有且仅有一条路径，即图中不存在环，这样的图称为树，一般记为T。
树定义有以下几种表述：(1)、T连通、无圈、有n个结点，连通有n－1条边；(2)、T无回路，但不相邻的两个结点间联以一边，恰得一个圈；(3)、T连通，但去掉任意一边，T就不连通了（即在点集合相同的图中，树是含边数最少的连通图）；(4)、T的任意两个结点之间恰有一条初等链。
例如：已知有六个城市，它们之间要架设电话线，要求任意两个城市均可以互相通话，并且电话线的总长度最短。
若用六个点v1…v6代表这六个城市，在任意两个城市之间架设电话线，即在相应的两个点之间连一条边。
这样，六个城市的一个电话网就作成一个图。
任意两个城市之间均可以通话，这个图必须是连通图，且这个图必须是无圈的。
否则，从圈上任意去掉一条边，剩下的图仍然是六个城市的一个电话网。
图5-6是一个不含圈的连通图，代表了一个电话线网。
生成树（支撑树）定义：如果图G’是一棵包含G的所有顶点的树，则称G’是G的一个支撑树或生成树。
例如,图5-7b是图5-7a的一个支撑树。
定理：一个图G有生成树的条件是G是连通图。
证明:必要性显然；充分性:设图G是连通的，若G不含圈，则按照定义，G是一个树，从而G是自身的一个生成树。
若G含圈，则任取G的一个圈，从该圈中任意去掉一条边，得到图G的一生成子图G1。
若G1不含圈，则G1是G的一个生成树。
若G1仍然含圈，则任取G1的一个圈，再从圈中任意去掉一条边，得到图G的一生成子图G2。
依此类推，可以得到图G的一个生成子图G K，且不含圈，从而G K是一个生成树。
寻找连通图生成树的方法：破圈法：从图中任取一个圈，去掉一条边。
再对剩下的图重复以上步骤，直到不含圈时为止，这样就得到一个生成树。
取一个圈(v1,v2,v3,v1)，在一个圈中去掉边e3。
在剩下的图中，再取一个圈（v1,v2,v4,v3,v1），去掉边e4。
再从圈（v3,v4,v5,v3）中去掉边e6。
再从圈(v1,v2,v5,v4,v3,v1）中去掉边e7，这样，剩下的图不含圈，于是得到一个支撑树，如图所示。
避圈法：也称为生长法，从图中某一点开始生长边，逐步扩展成长为一棵树，每步选取与已入树的边不构成圈的那些边。
二、最小生成树概念：设G=(V,E)是无向连通带权图，即一个网络。
E中每条边(v,w)的权为c[v,w]。
所有生成树G’上各边权的总和最小的生成树称为G的最小生成树。
应用：如在设计通信网络时，用图的顶点表示城市，用边(v,w)的权c[v，w]表示建立城市v、w之间的通信线路所需的费用，则最小生成树就给出了建立通信网络最经济的方案。
性质：设G=(V,E)是连通带权图，U是V的真子集。
若(u,v)∈E，且u∈U，v∈V-U，且在所有这样的边中，(u,v)的权c[u，v]最小，那么一定存在G的一棵最小生成树，它以(u,v)为其中一条边。
这个性质也称为MST性质。
算法：经典方法有两种：kruskal、prim算法（贪心思想）：一次生成一条最短边。
【Prim算法】：算法思想：任意时刻的中间结果都是一棵树，每次花费最小的代价，用一条边把不在树中的结点加进来。
按结点来贪，因此适用于稠密图的处理.算法内容：①设置顶点集合V和边集E，它们的初始状态为空集。
②任意选取一个顶点A加入V中。
③重复以下过程直到V中已经包含原图的所有节点：1、选一条权值最小的边(u,v)，并使其满足u,v两节点只有一个在点集V中。
2、将两个节点中不在V的那个点加入集合V中，并将边(u,v)加入边集E中。
④所得的子图G’=(V,E)即为所求的最小生成树。
关键：找出当前最优得一条边,穷举每一条不在集合E中的边，找出符合条件且最优的边。
时间复杂度：O（V*E），即顶点数乘以边数。
代码：varn,i,j,k,min,sum:longint;a:array[1..1000,1..1000]of longint;b,d:array[1..1000]of longint;procedure prim;beginsum:=0;for i:=1 to n do d[i]:=a[1,i];for j:=2 to n dobeginmin:=maxlongint;for i:=1 to n doif (d[i]<min)and(d[i]<>0) thenbeginmin:=d[i]; k:=i;end;sum:=sum+d[k]; d[k]:=0;for i:=1 to n doif (a[k,i]<d[i])and(i<>k) then d[i]:=a[k,i];end;end;beginreadln(n);for i:=1 to n dofor j:=1 to n dobeginread(a[i,j]);if (i<>j) and (a[i,j]=0) then a[i,j]:=maxlongint;end;//初始化prim;writeln(sum);end.Prim算法：初始状态A包含任意一个顶点r，从r开始，每次都向A中添加一条连接树A和G=（V,A）中某个孤立顶点的轻边，直至生成树A包含了图中所有的顶点。
有效实现该算法的关键是设法较容易地选择一条轻边。
我们可以借助最小优先级队列。
图中的顶点可以分为两类，一类是在A中的，已经纳入最小生成树了，另一种是不在A 中的，记为B，对于这些顶点，我们需要保存它们与A中的某个顶点相连的边中的最小权值。
最小优先级队列保存的就是B（尚未纳入最小生成树）中的顶点以及它们与A中某个顶点相连的边中的最小权值。
每次队首出队，设新加入A的顶点为V，那么我们要修改V的邻接点中尚未在A中（在最小优先级队列）的且与A中顶点相连的边的最小权值（比较拗口）。
Prim+heapy优化：*优化：在选择权值最小的可行边时可以使用堆。
(nlogn) 堆优化的Prim算法适用于稀疏图，而不优化的Prim算法适用于稠密图。
代码：varn,i,j,k,sum:longint;a:array[0..1000,0..1000]of longint;b,d,heap,pos:array[0..10000]of longint;procedure swap(var i,j:longint);{交换整数i和j}//省略procedure heapify(p:longint);{向下调整堆的过程}var best:longint;beginbest:=p;//下面两个if是分别判断根和左、右孩子最短距离的大小if (p*2<=j-1) and (key[heap[p*2]]<key[heap[best]]) then best:=p*2;if (p*2+1<=j-1) and (key[heap[p*2+1]]<key[heap[best]]) then best:=p*2+1;if best<>p then//若根有所变动，即跟比左右孩子都大（最短距离）beginswap(pos[heap[p]],pos[heap[best]]);//互换节点heap[p]、heap[best]在堆的位置swap(heap[p],heap[best]);//互换堆中元素p、bestheapify(best);//继续调整互换后的元素bestend;end;procedure modify(id,new_d:longint);{判断new_d与d[id]大小，并修改key[id]大小}var p:longint;beginif (new_d<d[id]) thenbegin//修改d[id]:=new_d;//更新最短距离p:=pos[id];//结点id在堆中的位置while (p>1) and (key[heap[p]]<key[heap[p div 2]｛父｝]) do//向上调整beginswap(pos[heap[p]],pos[heap[p div 2]]);swap(heap[p],heap[p div 2]);p:=p div 2;//更上一层end;end;end;procedure extract（抽出）(var id:longint);{读取堆中最小元素的节点编号}beginid:=heap[1];//堆顶swap(pos[heap[1]],pos[heap[j]]);// 堆顶的元素和第j个元素换位置swap(heap[1],heap[j]);//把堆顶的元素扔到j后面去，heapify(1);//此时堆顶不一定是最小的~扔到下面去，把最小的搞上来。
end;procedure prim;begind[1]:=0;for j:=n downto 1 dobeginextract(k);sum:=sum+d[k];for i:=1 to n doif (pos[i]<j) then modify(i,a[k,i]);end;beginreadln(n);for i:=1 to n dofor j:=1 to n dobeginread(a[i,j]);if (i<>j) and (a[i,j]=0) then a[i,j]:=maxlongint;end;//初始化for i:=1 to n dobeginheap[i]:=i; pos[i]:=i; d[i]:=maxlongint;end;prim;writeln(sum);end.【Kruskal算法】算法内容：初始时把每个顶点看作一个集合①将所有边以长度为关键词从小到大排序。
②将每个顶点都加入一个集合中，即N个顶点共N个集合。
③设置边集E，初始状态为空。
④从小到大访问每条边，若边连接的两个顶点属于不同集合，则合并两个顶点所在的集合，并将该边加入到边集E中。
⑤所得的子图TG=(V,E)即为所求的最小生成树，其中顶点集V就是原图的所有顶点。
**关键：集合的合并。
我们可以采用路径压缩的算法，用树结构作为集合的结构，对于每个点只记录它的父亲，集合的代表元素即为树的根。
在判断两个节点是否属于同一集合时，递归查找节点所在树的根，同时压缩路径。
合并集合只需将集合B的根的父亲记为集合A 的根即可。
时间复杂度：O（eloge）x,j,tot,i,n:longint;l,a,b:array[1 ..10000] of longint;f:array[1 ..100] of longint;procedure qs(low,high:longint); //以每条边的长度排序；function find(x:longint):longint;//找集合的根结点、var tmp: longint;beginif f[x]=x then exit(x) else exit(find(f[x]));end;procedure union(u,v:longint); //合并子集varfu,fv:longint;beginfu:=find(u);fv:=find(v);f[fv]:=fu;end;procedure kruskal;varcnt,i,ans:longint;beginfor i:=1 to n do f[i]:=i;//初始子集，都是自己；cnt:=0; ans:=0;for i := 1 to tot doif (find(a)<>find(b)) then//判断是否属于同一子集beginunion(a,b);inc(ans); inc(cnt);if cnt=n-1 then break; //n个结点，连接n-1条边end;writeln(ans);end;begintot:= 0; readln(n);for i:=1 to n dofor j := 1 to n dobeginread(x);if (i<>j) thenbegininc(tot); a[tot]:= i; b[tot] := j; l[tot]:= x;end;end;qsort(1,tot);kruskal;end.1.Prim在稠密图中比Kruskal优，在稀疏图中比Kruskal劣。