Prim最小生成树算法实验报告材料

合集下载

最小生成树 实验报告

最小生成树 实验报告

最小生成树实验报告最小生成树实验报告一、引言最小生成树是图论中的一个重要概念,它在实际问题中有着广泛的应用。

本次实验旨在通过编程实现最小生成树算法,并通过实验数据对算法进行分析和评估。

二、算法介绍最小生成树算法的目标是在给定的带权无向图中找到一棵生成树,使得树上所有边的权重之和最小。

本次实验我们选择了两种经典的最小生成树算法:Prim 算法和Kruskal算法。

1. Prim算法Prim算法是一种贪心算法,它从一个顶点开始,逐步扩展生成树的规模,直到包含所有顶点为止。

算法的具体步骤如下:(1)选择一个起始顶点,将其加入生成树中。

(2)从与生成树相邻的顶点中选择一个权重最小的边,将其加入生成树中。

(3)重复上述步骤,直到生成树包含所有顶点。

2. Kruskal算法Kruskal算法是一种基于并查集的贪心算法,它首先将图中的边按权重从小到大进行排序,然后逐个加入生成树中,直到生成树包含所有顶点为止。

算法的具体步骤如下:(1)将图中的边按权重从小到大进行排序。

(2)逐个加入边,如果该边的两个顶点不在同一个连通分量中,则将其加入生成树中。

(3)重复上述步骤,直到生成树包含所有顶点。

三、实验过程本次实验我们使用C++语言实现了Prim算法和Kruskal算法,并通过随机生成的图数据进行了测试。

1. Prim算法的实现我们首先使用邻接矩阵表示图的结构,然后利用优先队列来选择权重最小的边。

具体实现过程如下:(1)创建一个优先队列,用于存储生成树的候选边。

(2)选择一个起始顶点,将其加入生成树中。

(3)将与生成树相邻的顶点及其边加入优先队列。

(4)从优先队列中选择权重最小的边,将其加入生成树中,并更新优先队列。

(5)重复上述步骤,直到生成树包含所有顶点。

2. Kruskal算法的实现我们使用并查集来维护顶点之间的连通关系,通过排序后的边序列来逐个加入生成树中。

具体实现过程如下:(1)将图中的边按权重从小到大进行排序。

最小生成树 实验报告

最小生成树 实验报告

最小生成树(Minimum Spanning Tree)实验报告1. 实验目的本实验旨在通过实践掌握最小生成树算法的基本原理和实现方法。

最小生成树是图论中的一个重要概念,用于解决具有权重的连通图的最优路径问题。

通过本实验,我们将学习如何使用最小生成树算法找到一棵连接图的所有节点且总权重最小的树。

2. 实验原理最小生成树是一个连通图的一种生成树,它的所有边的权重之和最小。

最小生成树的求解算法有多种,其中两种常用的算法是 Prim 算法和 Kruskal 算法。

2.1 Prim 算法Prim 算法是一种贪心算法,从一个节点开始,逐步扩展最小生成树的边。

具体步骤如下: 1. 选择一个起始节点作为最小生成树的根节点。

2. 在当前最小生成树的所有节点中选择一个与该树相连接的权重最小的边,将其加入最小生成树。

3. 将该节点标记为已访问。

4. 重复步骤 2 和步骤 3,直到所有节点都被访问。

2.2 Kruskal 算法Kruskal 算法也是一种贪心算法,通过不断选择权重最小的边来构建最小生成树。

具体步骤如下: 1. 对所有边按照权重进行排序。

2. 依次选择权重最小的边,如果该边的两个端点不在同一个连通分量中,则将该边加入最小生成树,并将这两个端点合并到同一个连通分量中。

3. 重复步骤 2,直到所有节点都在同一个连通分量中,即最小生成树构建完成。

3. 实验步骤本实验将使用 Prim 算法和 Kruskal 算法分别求解给定图的最小生成树。

3.1 数据准备首先,我们需要准备一个具有权重的连通图作为实验数据。

假设该图有 n 个节点和 m 条边,我们可以使用邻接矩阵或邻接表来表示这个图。

3.2 Prim 算法求解最小生成树1.首先,选择一个起始节点作为最小生成树的根节点,并将该节点标记为已访问。

2.初始化一个空的最小生成树,用于存储最终的结果。

3.重复以下步骤,直到所有节点都被访问:1.在当前最小生成树的所有节点中选择一个与该树相连接的权重最小的边,将其加入最小生成树。

Prim最小生成树算法

Prim最小生成树算法

福建农林大学计算机与信息学院(程序设计类课程)实验报告课程名称:数据结构姓名:许章赫系:计算机与信息专业:计算机科学与技术(专升本)年级:2008学号:081806064指导教师:黄思先职称:副教授福建农林大学计算机与信息学院实验报告系:计算机与信息专业:计算机科学与技术(专升本) 年级:08级姓名:许章赫学号:081806064 实验室号田家炳513计算机号实验三Prim最小生成树算法一、实验目的和要求●理解图的遍历●理解构造无向联通图的最小生成树的方法(Prim算法算法)●能用Prim算法或Kruskal算法构造最小生成树出来●区别Prim算法与Kruskal算法二、实验内容和原理⑴实验内容:用Prim算法或Kruskal算法构造一颗最小生成树(本人在本实验中选择用Prim算法)(2) 实验原理:①从网中任一顶点开始,先把该顶点包含在生成树中,此时生成树只有一个顶点。

②找出一个端点在生成树中另一端点在生成树外的所有边,并把权值最小的边连到同它所关联的另一个顶点添加到生成树中;当有两条及以上具有相同最小权值的边可供选择时,任选一条。

③反复执行②,直到所有顶点都包含在生成树时为止。

三、实验环境硬件:(1)学生用微机(2)多媒体实验教室软件:(1)Windows XP中文操作系统(2)Visual Studio 2005四、算法描述及实验步骤1、算法描述例:有向图(a)初态(b)一条边(c)两条边(d)三条边(e)四条边(f)五条边(g)终态2、N-S表示3、代码(注释)#include "stdio.h"#include "conio.h"#include "malloc.h"#define N0 10#define infi 32767typedef int AdjMatrix[N0+1][N0+1]; typedef struct arcnode{int v,w;struct arcnode *next;}ArcNode;AdjMatrix adjmatrix;int n; //邻接矩阵的行列数void createAdj(){int i,j,w,k;ArcNode *p;printf("n:");scanf("%d",&n); //输入方阵的行列数printf("0:No dir");scanf("%d",&k); //输入是否有向for(i=1;i<=n; i++) //初始化方阵对角线为,其余为最大()for(j=1; j<=n; j++)if(i==j) adjmatrix[i][j]=0;else adjmatrix[i][j]=infi;do{printf("i,j,w:");scanf("%d%d%d", &i,&j, &w); //输入有直接相连的两节点及其权值 if(i<1 || i>n || j<1 || j>n)//当i,j 小于或大于n时break; //退出循环adjmatrix[i][j]=w; //邻接矩阵的i行j列的权值为wif(k==0) //若为无向图{adjmatrix[j][i]=w; //邻接矩阵对称}}while(1); //永远}void prim(int x) //从顶点x开始{int min2tree[N0+1], closest[N0+1],i,j,k;int min;for(i=1; i<=n; i++) //设置所有顶点与开始顶点x相连closest[i]=x;for(i=1; i<=n; i++)//设置到树的权值为到根x的距离min2tree[i]=adjmatrix[x][i];for(i=1; i<=n-1; i++) //生成树{min=infi;k=0;for(j=1; j<=n; j++) //选择到树的权值最小的边if( min2tree[j]!=0 && min2tree[j]<min ){min=min2tree[j];k=j;}min2tree[k]=0; //将该顶点加入生成树中for(j=1; j<=n; j++)//不是自身&&到树的最小权值大于到新添加的生成树的顶点的权值if( min2tree[j]!=0 && min2tree[j]>adjmatrix[k][j] ){min2tree[j]=adjmatrix[k][j];closest[j]=k;//顶点j与顶点k相连}}for(i=1; i<=n; i++) //输出生成树{j = closest[i]; //j为生成树中与i相连的顶点if( i!=j ) //不是自身printf("(%d->%d)",i,j);}printf("\n");}void main(){createAdj();printf("\nPrim:");prim(1);getch();}五、调试过程调试过程及其麻烦,出现过字母错误,逻辑错误,以及语法错误,通过老师和许多同学的帮助最终解决。

最小生成树算法实验报告

最小生成树算法实验报告

最小生成树算法实验报告【实验报告】最小生成树算法实验一、实验目的本次实验旨在研究最小生成树算法,通过对比不同的算法,并对实验结果进行分析,探索最小生成树算法的优劣势和适应场景。

二、实验过程1.算法介绍本次实验中我们将使用两种最小生成树算法:普里姆算法和克鲁斯卡尔算法。

- 普里姆算法(Prim算法):从一个顶点开始,不断在剩下的顶点中选择到当前已有的最小生成树的距离最小的边,将该边的另一个顶点加入树中,直到所有的顶点都加入树中。

- 克鲁斯卡尔算法(Kruskal算法):首先将所有边按照权值从小到大进行排序,然后以最小权值的边开始,依次选择权值最小且不会形成环路的边,直到找到n-1条边为止,其中n为顶点数。

2.实验步骤首先,我们使用Python语言实现了普里姆算法和克鲁斯卡尔算法。

然后,我们构造了一些测试用例,包括不同规模的图和不同权值分布的图。

最后,我们对实验结果进行对比分析。

三、实验结果1.测试用例设计我们设计了三个测试用例,分别为小规模图、中规模图和大规模图,具体如下:-小规模图:顶点数为5的图,权值随机分布。

-中规模图:顶点数为50的图,权值随机分布。

-大规模图:顶点数为100的图,权值随机分布。

2.实验结果分析我们的实验结果如下表所示:算法,小规模图,中规模图,大规模图:-------:,:------:,:------:,:------:普里姆算法,13,455,703从实验结果可以看出,对于小规模图和中规模图,普里姆算法的运行时间明显低于克鲁斯卡尔算法。

但是对于大规模图,克鲁斯卡尔算法的运行时间与普里姆算法的运行时间差距不大,甚至略小于普里姆算法。

这是因为克鲁斯卡尔算法中排序边的时间复杂度为O(ElogE),而普里姆算法中筛选最小距离的边的时间复杂度为O(V^2)。

综上所述,普里姆算法适用于较小规模的图,而克鲁斯卡尔算法适用于较大规模的图。

四、实验总结本次实验研究了最小生成树算法,通过对比实验结果,我们发现不同算法在不同规模的图上的表现有所差异。

最小生成树算法实验报告

最小生成树算法实验报告

最小生成树算法问题描述设G=(V,E)是一个无向连通带权图,E中每条边(v,w)的权为c(v,w)。

如果G 的一个子图G'是一棵包含G的所有顶点的书,则称G'为G的生成树。

生成树上各边权的总和称为该生成树的耗费,在G的所有生成树中,耗费最小的生成树就称为G的最小生成树。

给定一个无向连通带权图,构造一个最小生成树。

设计思想利用Prim 算法求最小生成树,Prim 算法是利用贪心策略设计的算法。

设G=(V,E)是一个连通带权图,V={1, 2,…,n}。

构造G的一棵最小生成树的Prim算法的基本思想是:首先置U={1},然后,只要U是V的真子集,就做如下的贪心选择:选取满足条件i € U,j € V-U,且使c(i,j)达到最小的边(i,j), 并将顶点j添加到U中。

这个过程一致进行到U=V时为止。

在这个过程中选取到的所有边恰好构成G的一棵最小生成树。

时间复杂度Prim 算法的Pascal 语言描述如下:Procedure PRIM(c:array[1..n,1..n] of real);Varlowcost:array[1..n] of real; closest:array[1..n] of integer;i,j,k,min,integer; begin(I)for i:=2 to n do⑵begin{初始化,此时U只含有顶点1}(3)lowcost[i]:=c[1,i];(4)Closest[i]:=1;(5)end;(6)for i:=2 to n do(7)begin {寻找顶点分别在V-U与U中边权最小的边}(8)min:=lowcost[i];(9)j:=i;(10)For k:=2 to n do(II)If lowcost[k]<min then(12)Begin(13)Min:=lowcost[k];(14)j:=k;(15)End;(16)print(j,closest[j]);{ 输出找到的边}(17)Lowcost[j]:= %;{将j 添加到U}(18)For k:=2 to n do { 调整lowcost 和closest}(19)if(c[j,k]<lowcost[k])and(lowcost[k]< %)then(20)Begin(21)Lowcost[k]:=c[j,k];(22)Closest[k]:=j;(23)End(24)End(25)End;{PRIM}上述过程中第(6)~(24) 行的for 循环要执行n-1 次,每次执行时,第(10)~(15)行和第(18)~(23)行的for循环都要0(n)时间,所以Prim算法所需的计算时间为O(n2 )。

prim计算实验报告

prim计算实验报告

prim计算实验报告Prim计算实验报告引言:Prim算法是一种常用的图论算法,用于解决最小生成树问题。

在本次实验中,我们通过使用Prim算法,对一个给定的图进行计算,并得出最小生成树。

一、实验目的本次实验的目的是熟悉Prim算法的原理和实现方法,通过实际操作,了解算法的具体过程和效果。

同时,通过对比实验结果,探讨Prim算法在不同图结构下的优劣势。

二、实验方法1. 算法原理Prim算法是一种贪心算法,它从一个顶点开始,逐步扩展最小生成树的边集合,直到包含所有顶点为止。

具体步骤如下:(1)选择一个起始顶点,将其加入最小生成树的顶点集合。

(2)从与选定顶点相连的边中,选择一条权值最小的边,将其加入最小生成树的边集合。

(3)将新加入的顶点也加入最小生成树的顶点集合。

(4)重复步骤(2)和(3),直到最小生成树的顶点包含所有顶点。

2. 实验步骤(1)读取图的数据,构建邻接矩阵表示图的结构。

(2)选择一个起始顶点,将其加入最小生成树的顶点集合。

(3)从与选定顶点相连的边中,选择一条权值最小的边,将其加入最小生成树的边集合。

(4)将新加入的顶点也加入最小生成树的顶点集合。

(5)重复步骤(3)和(4),直到最小生成树的顶点包含所有顶点。

(6)输出最小生成树的边集合和权值。

三、实验结果我们选择了一个具有10个顶点和15条边的图进行实验。

经过计算,得出的最小生成树的边集合和权值如下:边集合:(1, 2),(1, 3),(2, 4),(2, 5),(3, 6),(4, 7),(4, 8),(5, 9),(6, 10)权值之和:28四、实验分析通过对比实验结果,我们可以发现Prim算法在求解最小生成树问题上具有以下优势:1. 时间复杂度低:Prim算法的时间复杂度为O(V^2),其中V为顶点数。

相比于其他算法,Prim算法的时间复杂度较低,适用于大规模图的计算。

2. 结果唯一性:Prim算法得到的最小生成树是唯一的,不受图的表示方式和顶点选择的影响。

最小生成树实验报告

最小生成树实验报告

最小生成树实验报告1.引言最小生成树(Minimum Spanning Tree,简称MST)是图论中的重要概念,在各个领域都有广泛的应用。

最小生成树是指在给定的加权连通图中,选择一个子集,使得该子集包含了所有的顶点,并且所有边的权值之和最小。

本实验主要目的是探讨最小生成树的算法并比较它们的效率和准确性。

2.实验方法本次实验使用Python编程语言实现了两种著名的最小生成树算法:Prim算法和Kruskal算法。

Prim算法是一种贪心算法,从一个顶点开始不断扩张集合,直到包含所有顶点,生成最小生成树。

Kruskal算法则是基于并查集的算法,将边按照权值排序后逐一加入生成树,同时要保证加入的边不会产生环路。

3.实验过程首先,我们从文件中读取了一张加权无向图的数据。

图的表示采用邻接矩阵的方式,即用一个二维数组来存储顶点之间的连接关系和权值。

读取完图的数据后,我们分别使用Prim算法和Kruskal算法求解最小生成树。

在Prim算法中,我们使用一个辅助数组来记录顶点是否已被访问过,然后从任意一个顶点开始,依次将与当前集合相邻的顶点加入,并选择权值最小的边。

直到所有顶点都被访问过,并形成了一个最小生成树。

在Kruskal算法中,我们首先将所有边按照权值从小到大进行排序。

然后,从权值最小的边开始,逐一将边加入生成树。

加入时,需要判断两个顶点是否在同一个连通分量中,以避免产生环路。

实验中,我们使用了Python中的heapq库来实现了堆排序,以加快Prim算法的运行速度。

4.实验结果经过实验,我们得到了图的最小生成树以及对应的权值。

实验数据显示,当图中顶点较少时,Prim算法和Kruskal算法几乎没有明显的差别。

但当图的规模增大时,Prim算法明显比Kruskal算法更快。

5.实验分析从实验结果可以看出,Prim算法和Kruskal算法都可以求解最小生成树,但在不同情况下它们的性能表现并不相同。

Prim算法适用于稠密图,因为它的时间复杂度与顶点的平方成正比;而Kruskal算法适用于稀疏图,因为它的时间复杂度与边的数量成正比。

最小生成树prim算法实验报告

最小生成树prim算法实验报告

最小生成树prim算法实验报告最小生成树Prim算法实验报告引言:最小生成树(Minimum Spanning Tree,简称MST)是图论中的一个重要概念,意为在一个连通图中找到一棵生成树,使得树上所有边的权值之和最小。

Prim算法是一种常用的解决MST问题的贪心算法。

本实验旨在通过实际操作和观察,深入理解Prim算法的原理与过程。

实验目的:1. 理解Prim算法的基本原理;2. 掌握Prim算法的具体实现过程;3. 利用Prim算法求解最小生成树问题;4. 分析Prim算法的时间复杂度。

实验过程:1. 实验环境搭建:在实验开始前,我们需要搭建合适的实验环境。

首先,我们选择一种编程语言,如Python或C++,来实现Prim算法。

其次,我们需要准备一个图的数据集,可以是随机生成的或者是从现实问题中提取的。

最后,我们需要一个用于可视化的工具,以便观察Prim算法的执行过程和结果。

2. Prim算法实现:Prim算法的核心思想是从一个顶点开始,逐步扩展生成树,直到包含所有顶点为止。

具体实现过程如下:a. 初始化一个空的生成树,选择一个起始顶点;b. 在剩余的顶点中,选择与生成树距离最近的顶点,并将其加入生成树;c. 更新生成树与剩余顶点的距离,如果存在更短的路径,则更新;d. 重复步骤b和c,直到生成树包含所有顶点。

3. Prim算法求解最小生成树问题:利用Prim算法求解最小生成树问题的步骤如下:a. 根据实验环境搭建中准备的图数据集,构建图的邻接矩阵或邻接表表示;b. 选择一个起始顶点,将其加入生成树;c. 重复以下步骤,直到生成树包含所有顶点:i. 从生成树中选择一个顶点v,找到与v相连的顶点中距离最小的顶点u; ii. 将顶点u加入生成树,并将(u, v)边加入生成树的边集;iii. 更新生成树与剩余顶点的距离,如果存在更短的路径,则更新。

实验结果与分析:我们通过实验环境搭建和Prim算法实现,成功求解了多个最小生成树问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

算法分析与设计之Prim学院:软件学院学号:201421031059 :吕吕一、问题描述1.Prim的定义Prim算法是贪心算法的一个实例,用于找出一个有权重连通图中的最小生成树,即:具有最小权重且连接到所有结点的树。

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

2.实验目的选择一门编程语言,根据Prim算法实现最小生成树,并打印最小生成树权值。

二、算法分析与设计1.Prim算法的实现过程基本思想:假设G=(V,E)是连通的,TE是G上最小生成树中边的集合。

算法从U ={u0}(u0∈V)、TE={}开始。

重复执行下列操作:在所有u∈U,v∈V-U的边(u,v)∈E中找一条权值最小的边(u0,v0)并入集合TE中,同时v0并入U,直到V=U为止。

此时,TE中必有n-1条边,T=(V,TE)为G的最小生成树。

Prim算法的核心:始终保持TE中的边集构成一棵生成树。

2.时间复杂度Prim算法适合稠密图,其时间复杂度为O(n^2),其时间复杂度与边得数目无关,N 为顶点数,而看ruskal算法的时间复杂度为O(eloge)跟边的数目有关,适合稀疏图。

三、数据结构的设计图采用类存储,定义如下:class Graph{private:int *VerticesList;int **Edge;int numVertices;int numEdges;int maxVertices;public:Graph();~Graph();bool insertVertex(const int vertex);bool insertEdge(int v1,int v2,int cost);int getVertexPos(int vertex);int getValue(int i);int getWeight(int v1,int v2);int NumberOfVertices();int NumberOfEdges();void Prim();}其中,图中结点连接情况及权值使用二重指针表示,即二维数组实现邻接矩阵。

四、代码与运行结果代码运行结果:源码://普雷姆算法#include<iostream>using namespace std;const int maxWeight=10000;const int DefaultVertices=10000;const int maxEdges=10000;const int MAXINT = 10000000;class Graph{private:int *VerticesList;int **Edge;int numVertices;int numEdges;int maxVertices;public:Graph();~Graph();bool insertVertex(const int vertex);bool insertEdge(int v1,int v2,int cost);int getVertexPos(int vertex);int getValue(int i);int getWeight(int v1,int v2);int NumberOfVertices();int NumberOfEdges();void Prim();void lvlv(Graph &G);};istream& operator>>(istream& in,Graph &G); ostream& operator<<(ostream& out,Graph &G);//默认构造函数Graph::Graph(){maxVertices=DefaultVertices;numVertices=0;numEdges=0;int i,j;VerticesList=new int [maxVertices];Edge=(int **)new int *[maxVertices];for(i=0;i<maxVertices;i++)Edge[i]=new int[maxVertices];//邻接矩阵表示权值for(i=0;i<maxVertices;i++)for(j=0;j<maxVertices;j++)Edge[i][j]=(i==j)?0:maxWeight; };Graph::~Graph(){delete []VerticesList;delete []Edge;};//获取结点在结点数组中的下标,从0开始int Graph::getVertexPos(int vertex){for(int i=0;i<numVertices;i++)if(VerticesList[i]==vertex)return i;return -1;};//共有属性int Graph::getValue(int i){return (i>=0&&i<=numVertices)?VerticesList[i]:NULL;};int Graph::getWeight(int v1,int v2){return (v1!=-1&&v2!=-1)?Edge[v1][v2]:0;};int Graph::NumberOfVertices(){return numVertices;};int Graph::NumberOfEdges(){return numEdges;};//插入结点bool Graph::insertVertex(const int vertex){if(numVertices==maxVertices)return false;VerticesList[numVertices++]=vertex;return true;};//插入边,v1和v2为结点在数组的下标bool Graph::insertEdge(int v1,int v2,int cost){if(v1>-1&&v1<numVertices&&v2>-1&&v2<numVertices&&Edge[v1][v2]==maxWeight) {Edge[v1][v2]=Edge[v2][v1]=cost;numEdges++;return true;}elsereturn false;};//输入图信息istream& operator>>(istream &in ,Graph &G) {//边的围是n-1至n(n-1)/2,n为顶点数int edges,vertices,i,j,k;int start,end,weight;//输入顶点in>>vertices>>edges;for(i=1;i<=vertices;i++){G.insertVertex(i);}i=0;while(i<edges){in>>start>>end>>weight;j=G.getVertexPos(start);k=G.getVertexPos(end);if(j==-1||k==-1)cout<<"input error!"<<endl;else{G.insertEdge(j,k,weight);i++;}}return in;};//输出图对象ostream& operator<<(ostream &out,Graph &G) {int i,j,vertices,edges;int start,end,weight;vertices=G.NumberOfVertices();edges=G.NumberOfEdges();out<<vertices<<","<<edges<<endl;for(i=0;i<vertices;i++){for(j=i+1;j<vertices;j++){weight=G.getWeight(i,j);if(weight>0 && weight<maxWeight){start=G.getValue(i);end=G.getValue(j);out<<"("<<start<<","<<end<<","<<weight<<")"<<endl;}}}return out;};//普雷姆算法void Graph::Prim (){int *lowcost,*nearvex;int sum=0;lowcost=new int[numVertices];nearvex=new int[numVertices];for (int i=1;i<numVertices;i++){lowcost[i]=Edge[0][i]; //顶点0到各顶点的代价nearvex[i]=0; //及最短带权路径}nearvex[0]=-1; //顶点0到生成树顶点集合int count = 0; //生成树边值数组存放指针for(int i=1;i<numVertices;i++) //循环n-1次,加入n-1条边{int min=MAXINT;int v=0;for(int j=0;j<numVertices;j++){//顶点j不在最小生成树中且边<0,j>权值比min小if (nearvex[j]!=-1 && lowcost[j]<min ){v=j; //求生成树外顶点到生成树顶点具有最小min=lowcost[j]; //权值的边, v是当前具最小权值的边的位置}}//找到了下一个结点if(v!=0){ //v==0表示再也找不到要求的顶点了count++; //向生成树边值数组存放sum+=lowcost[v];nearvex[v]=-1; //作该边已加入生成树标记//更新权值for (int j=1;j<numVertices;j++){if (nearvex[j]!=-1 && Edge[v][j]<lowcost[j] ) //j不在生成树中{//需要修改lowcost[j] = Edge[v][j];nearvex[j] = v;}}}}int c=0;//cout<<sum<<endl;for(int k=1;k<numVertices;k++)c+=lowcost[k];cout<<c<<endl;}int main(){cout<<"请输入图结点数,边数和权值,格式如下:"<<endl;cout<<"结点数边数"<<endl;cout<<"结点结点权值"<<endl;cout<<"结点结点权值"<<endl;cout<<"结点结点权值"<<endl;Graph G;cin>>G;cout<<endl<<"图信息如下:"<<endl<<G;cout<<"最小生成树权值:";G.Prim();_sleep(100000);return 0;}/*test5 71 2 31 4 52 3 32 5 33 4 53 5 64 5 1 */。

相关文档
最新文档