图的深度广度遍历和最小生成树PRIM和KRUSCAL算法的实现
求无向图的最小生成树算法——Prim与Kruskal

求无向图的最小生成树算法——Prim与Kruskal一.Prim算法1.算法思想对于图G=(V,E),用Prim算法求最小生成树T=(S,TE)的流程如下① 初始化:设S、TE为空集,任选节点K加入S。
② 选取一条权值最小的边(X,Y),其中X∈S,且not (Y∈S)即,选取一条权值最小的、连接着S中一点与S外一点的边。
将Y加入S中,边(X,Y)加入TE中重复② 直到V=S即所有G中的点都在S中,此时的T为G的最小生成树。
由此流程可见,Prim算法求最小生成树时任何时候的T都是一颗树。
2.实现显然,Prim算法的主要运行时间花在过程②的选边中。
看起来复杂度是O(VE)=O(V^3)不是么,效率也太低了吧……为了比较快速地选边,我们用两个数组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。
设出发点为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】每一次找出lowcost中不为0的最小值lowcost[i],然后把i加入S(即lowcost[i]:=0),然后对于图中所有点k,若w(k,i)<lowcost[k],则把lowcost[k]赋为w(k,i),把closest[k]赋为i。
【由于s中所有点的lowcost都为0,所以只影响到s以外的点】以上操作重复|V|-1次结束。
最小生成树问题---Prim算法与Kruskal算法实现(MATLAB语言实现)

最⼩⽣成树问题---Prim算法与Kruskal算法实现(MATLAB语⾔实现) 2015-12-17晚,复习,甚是⽆聊,阅《复杂⽹络算法与应⽤》⼀书,得知最⼩⽣成树问题(Minimum spanning tree)问题。
记之。
何为树:连通且不含圈的图称为树。
图T=(V,E),|V|=n,|E|=m,下列关于树的说法等价:T是⼀个树。
T⽆圈,且m=n-1。
T连通,且m=n-1。
T⽆圈,但每加⼀新边记得到唯⼀⼀个圈。
T连通,但任舍去⼀边就不连通。
T中任意两点,有唯⼀道路相连。
何为⽣成树:若图G=(V,E)的⽣成⼦图是⼀棵树,则称该树为图G的⽣成树,也称⽀撑树,简称为图G的数。
图G中属于⽣成树的边称为数枝(Branch)。
何为最⼩⽣成树:连通图G=(V,E),每条边上有⾮负权L(e)。
⼀棵树上所有树枝权的总和,称为这个⽣成树的权。
具有最⼩权的⽣成树称为最⼩⽣成树,也就是说最⼩⽀撑树,简称最⼩树。
私以为,两种算法其实都是贪⼼,所以需要严格的证明。
由于最近时间零散、数学久置未学、对算法领域没有系统了解。
所以不进⾏深⼊探讨(也就是说证明),仅以⼀个简单实例做⼀个⼊门级的了解。
Prim算法: 给定连通赋权图G=(V,E,W),其中W为邻接矩阵,设两个集合P和Q,其中P⽤于存放G的最⼩⽣成树中的节点,集合Q存放G的最⼩G的最⼩⽣成树中的边。
另集合P的初值为P={v1}(假设构造最⼩⽣成树时从v1出发),集合Q的初值为P={空集}。
(1)P = {v1},Q = {空集}; (2)while P ~= Q 找到最⼩边pv,其中p∈P,v∈V-P; P = P + {v}; Q = Q + {pv}; end Kruskal算法 (1)选e1∈E(G),使得w(e1) = min(选e1的权值最⼩)。
(2)e1,e2,...,e i已选好,则从E(G)-{e1,e2,...,e i}中选取e i+1,使得G[{e1,e2,...,e i,e i+1}]中⽆圈,且,w(e i+1) = min。
的最小生成树算法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's Algorithm)是一种贪心算法,用于求解带权无向连通图的最小生成树。
它的基本思想是从一个起始顶点开始,逐步向最小代价的边添加顶点,直到生成一颗包含所有顶点的最小生成树。
下面是普里姆算法的具体步骤:1. 随机选择一个顶点作为起始顶点,并将其添加到最小生成树集合中。
2. 从最小生成树集合中已有的顶点出发,寻找与其相连的边中具有最小权值的顶点,将该顶点添加到最小生成树集合中。
3. 重复第二步,直到最小生成树集合包含所有顶点为止。
普里姆算法的时间复杂度为O(V^2),其中V为顶点数。
它的优点是简单易懂、容易实现,并且适用于稠密图。
然而,普里姆算法对于稀疏图的效率较低,因为需要频繁地搜索和更新权值最小的边。
二、克鲁斯卡尔算法克鲁斯卡尔算法(Kruskal's Algorithm)是一种基于边的贪心算法,用于求解带权无向连通图的最小生成树。
它的基本思想是通过选择代价最小的边,并判断是否会形成环路,最终构建出一颗最小生成树。
下面是克鲁斯卡尔算法的具体步骤:1. 将图中的所有边按照权值从小到大进行排序。
2. 依次选择权值最小的边,判断如果添加该边会形成环路,则将其舍弃;否则将其添加到最小生成树的边集合中。
3. 重复第二步,直到最小生成树的边数等于顶点数减一为止。
克鲁斯卡尔算法的时间复杂度为O(ElogE),其中E为边数。
相比普里姆算法,克鲁斯卡尔算法适用于稀疏图,并且对于大规模图的求解效率更高。
然而,克鲁斯卡尔算法的缺点是在构建最小生成树时需要尝试的边较多,因此在边数较多的情况下,算法的效率可能不高。
三、比较与总结普里姆算法和克鲁斯卡尔算法都是求解最小生成树问题的经典算法,它们各自具有不同的优点和适用场景。
基于Prim算法和Kruskal算法的最小生成树优化研究

一
然后 随便从右边 的集合 中拿出 个数到左边 的集 合来 ,并搜 出
它与 他 的 点所 订 连 线 酚 值 。 从 图中 可 以看 到 1到 3的距 离 是最 短 的 ,所 以 8一 定 为 最 小 生 成 树 中 的一 段 ,所 以我 们 将 3放 入 左 边 的 集 合 ,然 后 把 8这 个 数 加 到 ai 面 去 。并 用 3到 右 边 的 集 合 中 的 点 的距 离 去 刷 新 1到 右 边 i s里
最小生成树---普里姆算法(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数组记录各点的连通分量),则将其添加到最⼩⽣成树中。
采用普里姆算法和克鲁斯卡尔算法,求最小生成树

采用普里姆算法和克鲁斯卡尔算法,求最小生成树什么是最小生成树?最小生成树是图论中的一个重要概念,它是指在一个给定的无向连通图中,找到一棵树,使得这棵树连接图中的所有顶点,并且具有最小的权值总和。
最小生成树在很多实际问题中有着广泛的应用,比如城市规划、电力网络规划等。
普里姆算法:普里姆算法又称为“加点法”,它从一个初始随机点开始,逐渐往图中加入新的点,直到能够生成一棵包含所有节点的最小生成树。
1. 首先选择一个任意节点作为起始节点,加入最小生成树中。
2. 从已经加入最小生成树的节点中,选择一个与之相邻的节点并且不在最小生成树中的边,找到权值最小的边,将其加入最小生成树。
3. 重复第二步,直到最小生成树包含了所有的节点,即生成了一棵最小生成树。
克鲁斯卡尔算法:克鲁斯卡尔算法又称为“加边法”,它从原图的边集中选择权值最小的边,逐步加入生成树的边集中,直到遍历完所有的边,同时生成一棵最小生成树。
1. 首先把图中的所有边按照权值从小到大进行排序。
2. 依次遍历排序后的边,判断每一条边的两个顶点是否属于同一个连通分量。
3. 如果不属于同一个连通分量,将该边加入最小生成树的边集中,并将两个顶点所在的连通分量合并。
4. 重复第二步和第三步,直到遍历完所有的边或者最小生成树的边数达到图中节点数减一。
两种算法的比较:普里姆算法是从一个初始点开始,每次加入一个与最小生成树相连的具有最小权值的点,直到生成一棵最小生成树。
这种算法的时间复杂度为O(V^2),其中V表示图中的顶点数。
因此,普里姆算法适用于顶点数较少的情况。
克鲁斯卡尔算法是将边按照权值排序后逐步加入最小生成树的边集中。
这种算法的时间复杂度为O(ElogE),其中E表示图中的边数。
因此,克鲁斯卡尔算法适用于边数较少的情况。
从时间复杂度的角度来看,克鲁斯卡尔算法在边数较少的情况下更为高效,而普里姆算法在顶点数较少的情况下更为高效。
总结:最小生成树是一个在图论中非常重要且常用的概念,可以用于解决很多实际问题。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{ int i,j; for(i=0;i!=gra.vexnum;++i) visited[i]=0; for(j=0;j!=gra.vexnum;++j) { if(visited[j]==0) { dfs(gra,j); cout<<endl; } } return 0; } typedef struct { int adjvex; int lowcost; }closedge; int prim(int g[][max],int n) //最小生成树PRIM算法 { int lowcost[max],prevex[max]; //LOWCOST[]存储当前集合U分别到剩 余结点的最短路径 //prevex[]存储最短路径在U中的结 点 int i,j,k,min; for(i=2;i<=n;i++) //n个顶点,n-1条边 { lowcost[i]=g[1][i]; //初始化 prevex[i]=1; //顶点未加入到最小生成树中 } lowcost[1]=0; //标志顶点1加入U集合 for(i=2;i<=n;i++) //形成n-1条边的生成树 { min=inf; k=0; for(j=2;j<=n;j++) //寻找满足边的一个顶点在U,另一个顶点在V的最
{ int adjvex;//该弧指向的顶点的位置 struct arcnode *nextarc;//弧尾相同的下一条弧 char *info;//该弧信息 }arcnode; typedef struct vnode//邻接链表顶点头接点 { char data;//结点信息 arcnode *firstarc;//指向第一条依附该结点的弧的指针 }vnode,adjlist; typedef struct//图的定义 { adjlist vertices[max]; int vexnum,arcnum; int kind; }algraph; //…………………………………………队列定义…………………… typedef struct qnode { int data; struct qnode *next; }qnode,*queueptr; typedef struct { queueptr front; queueptr rear; }linkqueue; //……………………………………………………………………… typedef struct acr { int pre;//弧的一结点 int bak;//弧另一结点 int weight;//弧的权 }edg; int creatadj(algraph &gra,MGraph_L G)//用邻接表存储图 v.firstarc; while(p!=NULL&&p->adjvex!=w) { p=p->nextarc; } if(p->adjvex==w&&p->nextarc!=NULL) { p=p->nextarc; return p->adjvex; } if(p->adjvex==w&&p->nextarc==NULL) return -10; } int initqueue(linkqueue &q)//初始化队列 { q.rear=(queueptr)malloc(sizeof(qnode)); q.front=q.rear; if(!q.front) return 0; q.front->next=NULL; return 1; } int enqueue(linkqueue &q,int e)//入队 { queueptr p; p=(queueptr)malloc(sizeof(qnode)); if(!p) return 0; p->data=e; p->next=NULL; q.rear->next=p; q.rear=p; return 1; } int dequeue(linkqueue &q,int &e)//出队
arc->adjvex=j; p->nextarc=arc; arc->nextarc=NULL; p=arc; } } } } gra.vexnum=G.vexnum; gra.arcnum=G.arcnum; cout<<"图G邻接表创建成功!"<<endl; return 1; } void adjprint(algraph gra) //邻接表输出 { int i; for(i=0;i!=gra.vexnum;++i) { arcnode *p; cout<<i<<" "; p=gra.vertices[i].firstarc; while(p!=NULL) { cout<<p->adjvex; p=p->nextarc; } cout<<endl; } } int firstadjvex(algraph gra,vnode v)//返回依附顶点V的第一个点 //即以V为尾的第一个结点 { if(v.firstarc!=NULL) return v.firstarc->adjvex; } int nextadjvex(algraph gra,vnode v,int w)//返回依附顶点V的相对 于W的下一个顶点
for(we=firstadjvex(gra,gra.vertices[e]);we>=0;we=nextadjvex(gra,gra.verti { if(!visited[we]) {
visited[we]=1; cout<<gra.vertices[we].data; enqueue(q,we); } } }
} } int dfs(algraph gra,int i) { visited[i]=1; int we1; cout<<gra.vertices[i].data; for(we=firstadjvex(gra,gra.vertices[i]);we>=0;we=nextadjvex(gra,gra.verti { we1=we; if(visited[we]==0) dfs(gra,we); we=we1; } return 1; } int dfstra(algraph gra) { int i,j; for(i=0;i!=gra.vexnum;++i) { visited[i]=0; } for(j=0;j!=gra.vexnum;++j) { if(visited[j]==0) dfs(gra,j); } return 0; } int bfstra_fen(algraph gra)//求连通分量
{ queueptr p; if(q.front==q.rear) return 0; p=q.front->next; e=p->data; q.front->next=p->next; if(q.rear==p) q.rear=q.front; free(p); return 1; } int queueempty(linkqueue q)//判断队为空 { if(q.front==q.rear) return 1; return 0; } void bfstra(algraph gra)//广度优先遍历 { int i,e; linkqueue q; for(i=0;i!=gra.vexnum;++i) visited[i]=0; initqueue(q); for(i=0;i!=gra.vexnum;++i) if(!visited[i]) { visited[i]=1; cout<<gra.vertices[i].data; enqueue(q,i); while(!queueempty(q)) { dequeue(q,e);
arcnode *arc,*tem,*p; for(i=0;i!=G.vexnum;++i) { gra.vertices[i].data=G.vexs[i]; gra.vertices[i].firstarc=NULL; } for(i=0;i!=G.vexnum;++i) { for(j=0;j!=G.vexnum;++j) { if(gra.vertices[i].firstarc==NULL) { if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum) { arc=(arcnode *)malloc(sizeof(arcnode)); arc->adjvex=j; gra.vertices[i].firstarc=arc; arc->nextarc=NULL; p=arc; ++j; while(G.arcs[i][j].adj!=int_max&&j!=G.vexnum) { tem=(arcnode *)malloc(sizeof(arcnode)); tem->adjvex=j; gra.vertices[i].firstarc=tem; tem->nextarc=arc; arc=tem; ++j; } --j; } } else { if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum) { arc=(arcnode *)malloc(sizeof(arcnode));
图的深度广度遍历和最小生成树PRIM和KRUSCAL算法的实现 昨天上实验课,偶然看到这个程序,和大家一起共享一下..... //图的遍历和生成树求解实现 //(邻接矩阵、邻接表 —图的深度广度遍历算法的实现和最小生成树 PRIM和KRUSCAL算法的实现) #include <iostream> #include <malloc.h> using namespace std; #define int_max 10000 #define inf 9999 #define max 20 //…………………………………………邻接矩阵定义…………………… typedef struct ArcCell { int adj; char *info; }ArcCell,AdjMatrix[max][max]; typedef struct { char vexs[max]; AdjMatrix arcs; int vexnum,arcnum; }MGraph_L; //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ int localvex(MGraph_L G,char v)//返回V的位置 { int i=0; while(G.vexs[i]!=v) ++i; return i; } int creatMGraph_L(MGraph_L &G)//创建图用邻接矩阵表示 { char v1,v2; int i,j,w; cout<<"…………创建无向图…………"<<endl<<"请输入图G顶点和弧的 个数:(4 6)不包括“()”"<<endl;