提高实验—最小生成树的Prim算法 - 一.实验目的和要求 1、根据算法设计需要, 掌握连通网的灵活表示方法
最小生成树 实验报告
最小生成树实验报告最小生成树实验报告一、引言最小生成树是图论中的一个重要概念，它在实际问题中有着广泛的应用。
本次实验旨在通过编程实现最小生成树算法，并通过实验数据对算法进行分析和评估。
二、算法介绍最小生成树算法的目标是在给定的带权无向图中找到一棵生成树，使得树上所有边的权重之和最小。
本次实验我们选择了两种经典的最小生成树算法：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）将图中的边按权重从小到大进行排序。
Prim最小生成树 实验报告含源码
实验报告题目说明：POJ2395 Out of Ray题目大意：Beth有m个农场，农场之间有些相通，有些不通。
已知，Beth每一英里要一盎司的水，Beth希望走遍所有的农场但携带最少的水。
问：Beth最多需要带多少水？（每个农场都可以补充水）本程序利用Prim算法俩实现题目要求。
1.<创建>输入农场数和农场之间的距离（均为整数），程序给出连通判断。
2.修改路径按格式输入修改值，此时路线可能会改变。
3.<输出最大携带水量>，附上最小生成树实验说明：1.基本思想利用邻接表G [ ][ ] 储存农场信息，然后使用Prim算法来完成最小生成树的构建；最后寻找出最大边，如果农场是不连通的将给出提示，可以对路径修改。
2.函数模块（1）int InitiTable(int G[][MaxFarm],int num);//创建邻接表，返回值是农场数目{int j,k,TempValue;while(true){cout<<"请输入农场的数目:"<<' ';cin>>num;if(num<=MaxFarm&&num>0)break;cout<<"错误！请重新输入."<<endl<<endl;}for(j=0;j<num;j++){for(k=0;k<num;k++){if(j==k)G[j][k]=MaxWeight;else if(j<k){while(true){cout<<"请输入农场"<<j+1<<"至农场"<<k+1<<"的距离。
如果该路不存在请输入-1："<<endl;cin>>TempValue;if(TempValue>=-1&&TempValue<MaxWeight) break;cout<<"输入无效，请重新输入。
最小耗费生成树Prim算法实验报告
学生实验报告学院：软件与通信工程学院课程名称：算法设计与分析专业班级：软件工程142班姓名：周平学号： 0143987学生实验报告一、实验综述实现贪心法的下列六个算法之一：1、可切割背包问题2、单源点最短路径求解算法——Dijkstra算法3、Dijkstra算法的改进版4、最小耗费生成树Kruskal算法5、最小耗费生成树Prim算法6、最小耗费生成树Prim算法的改进版要求与说明：1、各人独立完成，2、实验报告要求有：算法说明与描述、代码、数据集合（各算法1 要求达到百、千级）。
3、实验报告要有2-3个截图，包括导入数据、重要中间过程、最后结果等；4、额外完成所实现的算法，每完成一个加1 分；5、程序要求用C 语言完成，每个实验报告的代码都会被测试，对运行环境有特别要求的需要专门说明，否则，程序测试不通过责任自负；6、实验报告都有步骤分，但是，程序测试结果与实验报告结果不相符的，将被加重扣分；7、严禁抄袭——代码重复度超过90%者视作抄袭，抄袭者以0 分记，可以对评审提出质疑。
疑。
2、实验仪器、设备或软件1、个人电脑2、Microsoft Visual Studio 2015二、实验过程（实验步骤、记录、数据、分析）实验代码如下:#include<stdio.h>#include<stdlib.h>#define MAX 100#define MAXCOST 0x7fffffffint graph[MAX][MAX];int Prim(int graph[][MAX], int n){/* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */ int lowcost[MAX];/* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */int mst[MAX];int i, j, min, minid, sum = 0;/* 默认选择1号节点加入生成树，从2号节点开始初始化 */for (i = 2; i <= n; i++){/* 最短距离初始化为其他节点到1号节点的距离 */lowcost[i] = graph[1][i];/* 标记所有节点的起点皆为默认的1号节点 */mst[i] = 1;}/* 标记1号节点加入生成树 */mst[1] = 0;/* n个节点至少需要n-1条边构成最小生成树 */for (i = 2; i <= n; i++){min = MAXCOST;minid = 0;/* 找满足条件的最小权值边的节点minid */for (j = 2; j <= n; j++){/* 边权值较小且不在生成树中 */if (lowcost[j] < min && lowcost[j] != 0){min = lowcost[j];minid = j;}}/* 输出生成树边的信息:起点，终点，权值 */printf("%c - %c : %d\n", mst[minid] + 'A' - 1, minid + 'A' - 1, min);/* 累加权值 */sum += min;/* 标记节点minid加入生成树 */lowcost[minid] = 0;/* 更新当前节点minid到其他节点的权值 */for (j = 2; j <= n; j++){/* 发现更小的权值 */if (graph[minid][j] < lowcost[j]){/* 更新权值信息 */lowcost[j] = graph[minid][j];/* 更新最小权值边的起点 */mst[j] = minid;}}}/* 返回最小权值和 */return sum;}int main(){printf("请输入点数和边数：");int i, j, k, m, n;int x, y, cost;char chx, chy;scanf("%d%d", &m, &n);/* 读取节点和边的数目 */getchar();printf("请输入边的信息：");/* 初始化图，所有节点间距离为无穷大 */for (i = 1; i <= m; i++){for (j = 1; j <= m; j++){graph[i][j] = MAXCOST;}}/* 读取边信息 */for (k = 0; k < n; k++){scanf("%c %c %d", &chx, &chy, &cost);getchar();i = chx - 'A' + 1;j = chy - 'A' + 1;graph[i][j] = cost;graph[j][i] = cost;}/* 求解最小生成树 */cost = Prim(graph, m);/* 输出最小权值和 */printf("Total:%d\n", cost);//system("pause");return 0;}代码说明：1、2个for循环都是从2开始的，因为一般我们默认开始就把第一个节点加入生成树，因此之后不需要再次寻找它。
用Prim算法构造最小生成树
用Prim算法构造最小生成树班级：2010级计算机1班学号：2010131116 ：才一、实验目的了解最小生成树的概念，掌握生成最小生成树的方法。
二、实验容建立一个含任意结点的无向连通网，并用Prim算法构造其最小生成树三、实验要点及说明如果无向连通图是一个网，则其所有生成树中必有一棵树的边的权值总和最小，这棵生成树为最小生成树。
Prim算法：在图G=（V，E）（V为顶点集，E为边集）中任选一顶点v0,令集合U={v0}为初态，在一个顶点在U中，另一顶点在V-U中的所有边中找权值最小的边（u,v）（U∈u,v∈V-U），并将v加入到U中，同时将边（u,v）加入集合T中（T的初态为空集），这样不断地扩大U，直至U=V，则集合T中的边为所求最小生成树的边四、算法思想与算法描述1、邻接矩阵的数据类型的定义如下：typedef struct{ int no; /*顶点编号*/string name; /*顶点其他信息*/} VertexType; /*顶点类型*/typedef struct/*图的定义*/{ int edges[MAXV][MAXV]; /*邻接矩阵*/int vexnum,arcnum; /*顶点数,弧数*/VertexType vexs[MAXV]; /*存放顶点信息*/}MGraph;2、临时数组的存放的数据类型struct {int closest; // U集中的顶点序号int lowcost; // 边的权值} closedge[MAXV];int const INF=32767; /*INF表示∞*/3、prime算法实现：（原理见实验说明）void prime(MGraph g,int v){int lowcost[MAXV];int min;int closest[MAXV];int i,j,k;for(i=0;i<g.vexnum;i++){lowcost[i]=g.edges[v][i];closest[i]=v;}for(i=1;i<g.vexnum;i++){min=INF;for(j=0;j<g.vexnum;j++)if(lowcost[j]!=0&&lowcost[j]<min){min=lowcost[j];k=j;}printf("边(%d,%d)权为:%d\n",closest[k],k,min);lowcost[k]=0;for(j=0;j<g.vexnum;j++)if(g.edges[k][j]!=0&&g.edges[k][j]<lowcost[j]){lowcost[j]=g.edges[k][j];closest[j]=k;}}}4、邻接矩阵的创建void CreatMGraph(MGraph &M){int n,e;cout<<"输入定点数:";cin>>n;M.vexnum=n;cout<<"输入弧数:";cin>>e;M.arcnum=e;for(int i=0;i<n;i++){for(int j=0;j<n;j++){if(i==j)M.edges[i][j]=0;elseM.edges[i][j]=INF;}}cout<<"输入边的权：（如1 2 3 表示点到点的权时）"<<endl; for(int i=0;i<2*e;i++){int x,y,z;cin>>x>>y>>z;M.edges[x][y]=z;}cout<<"输入点编号，名字："<<endl;for(int i=0;i<n;i++){int No;string str;cin>>No>>str;M.vexs[i].name=str;M.vexs[i].no=No;}}int const MAXV=164、主函数int main(void){MGraph m;CreatMGraph(m);cout<<"输出无向图的二维矩阵："<<endl;for(int i=0;i<m.vexnum;i++){for(int j=0;j<m.vexnum;j++){if(m.edges[i][j]==INF)cout<<" ";elsecout<<m.edges[i][j]<<" ";}cout<<endl;}cout<<"输入最小生成树："<<endl;prime(m,0);return 0;}五、实验测试及结果1.输入图的定点数和边数2.输入邻矩阵：3.顶点编号级名字的输入：4.运行结果：六、总结与体会实验任务基本完成，加深队算法思想的认识附源码：#include<iostream> #include<string> using namespace std;int const MAXV=16;typedef struct{ int no; /*顶点编号*/string name; /*顶点其他信息*/} VertexType; /*顶点类型*/typedef struct/*图的定义*/{ int edges[MAXV][MAXV]; /*邻接矩阵*/int vexnum,arcnum; /*顶点数,弧数*/VertexType vexs[MAXV]; /*存放顶点信息*/}MGraph;struct {int closest; // U集中的顶点序号int lowcost; // 边的权值} closedge[MAXV];int const INF=32767; /*INF表示∞*/void prime(MGraph g,int v){int lowcost[MAXV];int min;int closest[MAXV];int i,j,k;for(i=0;i<g.vexnum;i++){lowcost[i]=g.edges[v][i];closest[i]=v;}for(i=1;i<g.vexnum;i++){min=INF;for(j=0;j<g.vexnum;j++)if(lowcost[j]!=0&&lowcost[j]<min){min=lowcost[j];k=j;}printf("边(%d,%d)权为:%d\n",closest[k],k,min);lowcost[k]=0;for(j=0;j<g.vexnum;j++)if(g.edges[k][j]!=0&&g.edges[k][j]<lowcost[j]){lowcost[j]=g.edges[k][j];closest[j]=k;}}}void CreatMGraph(MGraph &M){int n,e;cout<<"输入定点数:";cin>>n;M.vexnum=n;cout<<"输入弧数:";cin>>e;M.arcnum=e;for(int i=0;i<n;i++){for(int j=0;j<n;j++){if(i==j)M.edges[i][j]=0;elseM.edges[i][j]=INF;}}cout<<"输入边的权：（如1 2 3 表示点到点的权时）"<<endl;for(int i=0;i<2*e;i++){int x,y,z;cin>>x>>y>>z;M.edges[x][y]=z;}cout<<"输入点编号，名字："<<endl;for(int i=0;i<n;i++){int No;string str;cin>>No>>str;M.vexs[i].name=str;M.vexs[i].no=No;}}int main(void){MGraph m;CreatMGraph(m);cout<<"输出无向图的二维矩阵："<<endl;for(int i=0;i<m.vexnum;i++){for(int j=0;j<m.vexnum;j++){if(m.edges[i][j]==INF)cout<<" ";elsecout<<m.edges[i][j]<<" ";}cout<<endl;}cout<<"输入最小生成树："<<endl;prime(m,0);return 0;}。
最小生成树算法实验报告
最小生成树算法实验报告【实验报告】最小生成树算法实验一、实验目的本次实验旨在研究最小生成树算法，通过对比不同的算法，并对实验结果进行分析，探索最小生成树算法的优劣势和适应场景。
二、实验过程1.算法介绍本次实验中我们将使用两种最小生成树算法：普里姆算法和克鲁斯卡尔算法。
- 普里姆算法（Prim算法）：从一个顶点开始，不断在剩下的顶点中选择到当前已有的最小生成树的距离最小的边，将该边的另一个顶点加入树中，直到所有的顶点都加入树中。
- 克鲁斯卡尔算法（Kruskal算法）：首先将所有边按照权值从小到大进行排序，然后以最小权值的边开始，依次选择权值最小且不会形成环路的边，直到找到n-1条边为止，其中n为顶点数。
2.实验步骤首先，我们使用Python语言实现了普里姆算法和克鲁斯卡尔算法。
然后，我们构造了一些测试用例，包括不同规模的图和不同权值分布的图。
最后，我们对实验结果进行对比分析。
三、实验结果1.测试用例设计我们设计了三个测试用例，分别为小规模图、中规模图和大规模图，具体如下：-小规模图：顶点数为5的图，权值随机分布。
-中规模图：顶点数为50的图，权值随机分布。
-大规模图：顶点数为100的图，权值随机分布。
2.实验结果分析我们的实验结果如下表所示：算法，小规模图，中规模图，大规模图:-------:，:------:，:------:，:------:普里姆算法，13，455，703从实验结果可以看出，对于小规模图和中规模图，普里姆算法的运行时间明显低于克鲁斯卡尔算法。
但是对于大规模图，克鲁斯卡尔算法的运行时间与普里姆算法的运行时间差距不大，甚至略小于普里姆算法。
这是因为克鲁斯卡尔算法中排序边的时间复杂度为O(ElogE)，而普里姆算法中筛选最小距离的边的时间复杂度为O(V^2)。
综上所述，普里姆算法适用于较小规模的图，而克鲁斯卡尔算法适用于较大规模的图。
四、实验总结本次实验研究了最小生成树算法，通过对比实验结果，我们发现不同算法在不同规模的图上的表现有所差异。
最小生成树，Prim算法实现
最⼩⽣成树，Prim算法实现最⼩⽣成树所谓最⼩⽣成树，就是⼀个图的极⼩连通⼦图，它包含原图的所有顶点，并且所有边的权值之和尽可能的⼩。
⾸先看看第⼀个例⼦，有下⾯这样⼀个带权图：它的最⼩⽣成树是什么样⼦呢？下图绿⾊加粗的边可以把所有顶点连接起来，⼜保证了边的权值之和最⼩：去掉那些多余的边，该图的最⼩⽣成树如下：下⾯我们再来看⼀个更加复杂的带权图：同样道理，下图绿⾊加粗的边可以把所有顶点连接起来，⼜保证了边的权值之和最⼩：去掉那些多余的边，该图的最⼩⽣成树如下：图的极⼩连通⼦图不需要回路，⽽是⼀个树形结构，所以⼈们才把它叫做最⼩⽣成【树】。
图的最⼩⽣成树也不是唯⼀的，同⼀个图可以有多个不同的最⼩⽣成树，但是他们的权值之和是⼀样的。
最⼩⽣成树的⽤处可多了，⽐如我们要在若⼲个城市之间铺设道路，⽽我们的预算⼜是有限的，那么我们就需要找出成本最低的⽅式铺路，最⼩⽣成树的作⽤就来了。
怎样铺设才能保证成本最低呢？城市之间的交通⽹就像⼀个连通图，我们并不需要在每两个城市之间都直接进⾏连接，只需要⼀个最⼩⽣成树，保证所有的城市都有铁路可以触达即可。
通常⽣成最⼩⽣成树常⽤的算法有两种，⼀种是 Kruskal 算法，另⼀种是 Prim 算法。
下⾯介绍下 Prim 算法Prim算法是如何⼯作的呢？这个算法是以图的顶点为基础，从⼀个初始顶点开始，寻找触达其他顶点权值最⼩的边，并把该顶点加⼊到已触达顶点的集合中。
当全部顶点都加⼊到集合时，算法的⼯作就完成了。
Prim算法的本质，是基于贪⼼算法。
接下来说⼀说最⼩⽣成树的存储⽅式。
我们最常见的树的存储⽅式，是链式存储，每⼀个节点包含若⼲孩⼦节点的指针，每⼀个孩⼦节点⼜包含更多孩⼦节点的指针：这样的存储结构很清晰，但是也相对⿇烦。
为了便于操作，我们的最⼩⽣成树⽤⼀维数组来表达，数组下标所对应的元素，代表该顶点在最⼩⽣成树当中的⽗亲节点。
（根节点没有⽗亲节点，所以元素值是-1）下⾯让我们来看⼀看算法的详细过程：1.选择初始顶点，加⼊到已触达顶点集合。
最小生成树算法实验报告
最小生成树算法问题描述设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算法求最小生成树
算法分析与设计实验报告第次实验}最小生成树N=4:最小生成树N=5:最小生成树N=6:通过本次实验明白了最小生成树贪心算法的设计思路，掌握了prim算法附录：完整代码#include<iostream>#include <stdio.h>#include <time.h>#include <iomanip>#include <string.h>#define MaxInt 0x3f3f3f3f#define N 110using namespace std;//创建map二维数组储存图表，low数组记录每2个点间最小权值，visited数组标记某点是否已访问int map[N][N],low[N],closest[N],visited[N];int n;int prim(){int i;int min=MaxInt,result=0;memset(visited,0,sizeof(visited));visited[1]=1;//从某点开始，分别标记和记录该点for(i=2;i<=n;i++){low[i]=map[1][i];//给low数组赋值closest[i]=1;visited[i]=0;}for(i=1;i<n;i++)//运行n-1次{//找出最小权值并记录位置min=MaxInt;int k=1;for(int j=2;j<=n;j++)if(visited[j]==0&&min>low[j]){min=low[j];k=j;cout<<k<<"与"<<closest[k]<<"相连"<<endl;}result+=min;//最小权值累加visited[k]=1;//标记该点for(int j=2;j<=n;j++)//更新权值if(visited[j]==0&&low[j]>map[k][j]){low[j]=map[k][j];closest[j]=k;}}return result;}int main(){int i,p=0;double k=0.0;clock_t start,end,over;start=clock(); end=clock();over=end-start;start=clock();int v,j,ans;cout<<"(以EOF为程序结束符)输入顶点数n:";while(scanf("%d",&n)!=EOF){cout<<"输入n*n的权值矩阵:"<<endl;memset(map,MaxInt,sizeof(map));//所有权值初始化为最大for(i=1;i<=n;i++)for(j=1;j<=n;j++){cin>>v;map[i][j]=v;}ans=prim();cout<<"最小生成树的权值之和为："<<ans<<endl;for(i=0;i<1000000000;i++) p=p+i;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK);}return 0;}。
prim算法实验报告
prim算法实验报告Prim算法实验报告一、引言Prim算法是一种常用的最小生成树算法，用于在一个加权连通图中生成一棵覆盖所有顶点且边权和最小的树。
本实验旨在通过编程实现Prim算法，并分析其时间复杂度和实际应用。
二、算法描述Prim算法的基本思想是从一个初始顶点开始，逐步扩展生成树，每次选择与当前生成树连接的最短边对应的顶点，并将其加入生成树中，直到所有顶点都被加入为止。
具体步骤如下：1. 选择一个初始顶点作为生成树的根节点。
2. 在剩余的顶点中，选择与当前生成树连接的最短边对应的顶点，并将其加入生成树中。
3. 更新生成树与剩余顶点之间的边权，即若新加入的顶点到其他剩余顶点的距离更短，则更新距离。
4. 重复步骤2和步骤3，直到所有顶点都被加入生成树为止。
三、实验过程本实验使用C++编程语言实现Prim算法。
首先，通过邻接矩阵表示给定的加权连通图，其中顶点间的距离用边的权值表示，无连接的顶点间距离设为无穷大。
然后，选择一个初始顶点作为生成树的根节点，并将其加入生成树中。
接下来，循环执行以下步骤，直到所有顶点都被加入生成树为止：1. 找到与当前生成树连接的最短边对应的顶点，将其加入生成树中。
2. 更新生成树与剩余顶点之间的边权。
3. 记录每次加入生成树的边及其权值。
四、实验结果本实验使用了一个具体的加权连通图进行测试。
测试结果显示，Prim算法能够正确生成最小生成树，并且生成的树的边权和确实是最小的。
通过对比不同初始顶点的选择，发现生成树的形状可能会有所差异，但边权和仍然是最小的。
五、时间复杂度分析Prim算法的时间复杂度主要取决于两个因素：顶点数和边数。
在每次循环中，需要找到与当前生成树连接的最短边，这个过程需要遍历所有剩余顶点，时间复杂度为O(V)。
总共需要执行V次循环，因此Prim算法的时间复杂度为O(V^2)。
如果使用优先队列来优化寻找最短边的过程，时间复杂度可以降至O((V+E)logV)，其中E为边数。
最小生成树实验指导书.docx
实验1采用普里姆(prim)算法构造网络的最小生成树1、实验目的：深入理解最小生成树的概念，熟练掌握普里姆(prim)算法的工作过程，并通过定义合适的数据结构，釆用C语言程序实现。
2、实验内容：根据模板程序编制普里姆算法的程序，在计算机中进行调试，同时寻找两个结点大于6的网络，利用文件读入其邻接矩阵，运行程序。
记录运行结果，并把运行结果与手工生成的结果进行比较，验证程序的正解性。
要求从文本文件中读入网络的邻接矩阵。
3、实验原理①p rim算法的主要步骤②数据表示③算法实现细节4、实验步骤与实验结果①编写"im算法的C语言程序②输入计算机进行调试③准备两个顶点大于6的网络，把网络的邻接矩阵输入文本文件中，运行程序，记录程序的运行结果，根据结果画出最小生成树，并与手工生成的最小生成树进行比较。
实验结果：①画出网络图，写出相应的邻接矩阵②记录程序的运行结果，根据结果画出最小生成树并写出最小生成树的权值。
附录：程序模板#i nclude <std i o.h>/*定义一个结构体，用于记录一条边的始点与终点*/typedef struct pp{int p, q;} edge;i nt g [100] [100], u [100], v [100], vexnum;edge p[100] ;//用于记录最小生成树的各条边void input ()//读入图的邻接矩阵{i nt i, j, temp;FILE *fp;fp=fopen ("pp5. txt", " r");fscanf (fp,"%d"，&vexnum);for (i=1;i<=vexnum;i++){printf(H\n n);for (j=1;j<=vexnum;j++){fscanf (fp, "%d", &temp);g[i] [jl=temp;pr i ntf (”％d ", temp);}}fclose (fp);}ma i n (){i nt i, j, k, m, n, ma, s=0;inputO;//输入数据for (ih ; iUvexnum; i++)//集合V中包含了所有顶点v[i]二 1 ；u[1]=1 ；v[1]=0;//第1个节点加入至集合U中，并从集合V中去掉for (i=1; i<=vexnum-1 ; i ++) //最多需vexnum-1 条边{〃以下找连接节点集U至节点集V的最小边ma=1000;//ma存放最小边的权值for (j=1;j<=i;j++)//集合U中的第j个节点，其编号为u[j],每次增加一个，共for (k=1;k<=vexnum;k++)/*v[k]!=0表示节点k在集合V中;g[u[j][k]>0表示有边*/ if(v[k] !=0&&ma>g[u[j]] [k]&&g[u[j]] [k]>0){ma二g[u[j]] [k] ；//保存最小边值m二u[j] ;//最小边的始点编号n二k;//最小边的终点编号}s=s+ma; // 求和u[i+1]=n;v[n]=0;//把找到最小边的终点编号从V中去掉，并加入至U中p[i]. p二m;p[i]. q二n;//保存最小边的始点编号与终点编号}printfC'\n H)；for (i=1;i<=vexnum-1;i++)pr intf ("\n%d %d %d", p[i]. p, p[i]. q, g[p[i]. p] [p[i]. q]);printf("\nsum=%d\n\n",s);采用克鲁斯卡尔(kruskal)M法构造网络的最小生成树实验21、实验目的：深入理解最小生成树的概念，熟练掌握克鲁斯卡尔(kruskal)算法的工作过程，并通过定义合适的数据结构，采用C语言程序实现。
PRIM算法图的最小生成树求解
湖南商学院课程设计设计名称 PRIM算法最小生成树求解课程名称算法导论学期 2010-2011学年第1学期学时学分 51学时 3学分专业班级信科0821 组员名单熊春辉周伟佳刘志超学号080320637 080320638 080320625指导老师王勇提交日期 2010年 11月27日PRIM 算法最小生成树求解一． 问题描述：在科技发展的年代，许多问题都需要找到最简洁，最经济的方法去加以实现。
假设在n 个城市之间建立通信联络网，则联通n 个城市只需要n-1条线路，这时，自然会考虑这样一个问题，如何在最节省经费的前提下建立这个通信网。
对于n 个顶点的连通网可以建立许多不同的生成树，每一颗生成树都可以是一个连通网。
现在，我们要选择这样一颗生成树，也就是使总的耗费最少。
这个问题就是构造连通网的最小代价生成树的问题。
可以推广到任意一个图的最小生成树问题。
我们通过学习与阅读发现了PRIM 算法有其解决这样问题的优越性。
二．算法设计与分析： 1.算法设计：构造最小生成树可以有多种算法。
其中多数算法利用了最小生成树的下列一种简称为MST 的性质：假设N=（V ，{E}）是一个连通图，U 是顶点集V 的一个非空子集。
若（u,v ）是一条具有最小权值的边，其中u 包含于U,v 包含于V-U ，则必存在一颗包含边（u,v ）的最小生成树。
更具体地说，我们维持一个集合S 包含于V ，在它上面已构造了到这步为止的生成树，初始,S={s}。
每次迭代我们在S 中增加一个结点，把结点v 加入S 能使“附加费用”min(e)=(u,v):u 属于S ，C （e ）达到最小，并且包含了在生成树中达到这个最小值的边e=（u,v ）.这样解决此问题。
2.算法描述：从U={u0}u0属于V,S={ }开始，重复执行下述步骤：在所有u 属于U ，v 属于V-U 的边（u,v)属于E 中找一条代价最小的边（u0,v0)并入集合S ，同时v0并入U ，直到U=V 为止，此时S 中必有n-1条边，则T=(V,{S})为G 的最小生成树 （3）结束 3.算法分析：普利姆算法算法是前人的劳动成果，是正确的，对于同一个图而言，普利姆算法的时间复杂度)(2n O ，n 为顶点数。
最小生成树的Prim算法提高型实验报告
黄冈师范学院提高型实验报告实验课题最小生成树的Prim算法（实验类型：□综合性■设计性□应用性）实验课程算法程序设计实验时间 2010年12月24日学生姓名周媛鑫专业班级计科 0801学号 200826140110一．实验目的和要求（1）根据算法设计需要, 掌握连通网的灵活表示方法;（2）掌握最小生成树的Prim算法;（3）熟练掌握贪心算法的设计方法;二．实验条件（1）硬件环境：实验室电脑一台（2）软件环境：winTC三．实验原理分析（1）最小生成树的定义：假设一个单位要在n个办公地点之间建立通信网，则连通n个地点只需要n-1条线路。
可以用连通的无向网来表示n个地点以及它们之间可能设置的通信线路，其中网的顶点表示城市，边表示两地间的线路，赋于边的权值表示相应的代价。
对于n个顶点的连通网可以建立许多不同的生成树，每一棵生成树都可以表示一个通信网。
其中一棵使总的耗费最少，即边的权值之和最小的生成树，称为最小生成树。
（2）构造最小生成树可以用多种算法。
其中多数算法利用了最小生成树的下面一种简称为MST的性质：假设N=(V,{E})是一个连通网，U是顶点集V的一个非空子集。
若(u,v)是一条具有最小权值（代价）的边，其中u∈U，v∈V-U，则必存在一棵包含边 (u.v)的最小生成树。
（3）普里姆（Prim）算法即是利用MST性质构造最小生成树的算法。
算法思想如下：假设N=(V,{E})和是连通网，TE是N上最小生成树中边的集合。
算法从U={u0}( u0∈V)，TE={}开始，重复执行下述操作：在所有u∈U，v∈V-U的边(u, v) ∈E 中找一条代价最小的边(u0, v0)并入集合TE，同时v0并入U，直到U=V为止。
此时TE中必有n-1条边，则T=(V,{TE})为N的最小生成树。
四．实验步骤（1）数据结构的设计：采用邻接矩阵的存储结构来存储无向带权图更利于实现及操作：邻接矩阵的抽象数据结构定义：#define INFINITY INT_MAX //最大值#define MAX_ERTEX_NUM 20 //最大顶点数typedef enum {DG,DN,UDG,UDN}GraphKind;//{有向图,有向网，无向网，无向图} typedef struct Arc Cell{VRType adj ; // VRType 是顶点关系的类型。
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算法得到的最小生成树是唯一的，不受图的表示方式和顶点选择的影响。
最小生成树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算法实现，成功求解了多个最小生成树问题。
PRIM算法实验报告
篇一：prim算法实验报告算法实验报告学院：xxx班级：xxx学号：xxx姓名：xxx prim篇二：prim最小生成树算法实验报告算法分析与设计之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; 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();1public:} void prim();其中，图中结点连接情况及权值使用二重指针表示，即二维数组实现邻接矩阵。
图论编程实现PRIM实验报告
PRIM算法生成最小生成树一、实验目的了解PRIM的基本概念以及实现方式。
二、实验内容1、设计一个PRIM算法来形成图的最小生成树；2、在matlab中编程来实现此算法。
用下面的实例来调试程序：三、使用环境个人计算机，MATLAB软件四、编程思路PRIM法的基本思想：从邻接矩阵寻找、最小权值的点，将其顶点加入到生成树的顶点集合U中。
以后每一步从一个顶点在U中，而另一个顶点不在U中的各条边中选择权值最小的边(u, v),把该边加入到生成树的边集中，把它的顶点加入到集合U中。
如此重复执行，直到网络中的所有顶点都加入到生成树顶点集合U 中为止。
假设G=(V，E)是一个具有n个顶点的带权无向连通图，初始状态为空在所有u∈U，v∈V-U的边(u，v) ∈E中找一条代价最小的边(u′，v′)，同时将v′并入U；重复执行步骤，直到U=V为止。
五、调试过程1.程序代码：function road = prim(F)N = length(F); % 图G的顶点数road = []; % 记录路径的边表和权值 [u v w]k = 0;vis = zeros(1, N);vis(1) = 1; %生成一个顶点数的数组，第一个元素为1，存储权值while k < N-1minw = inf;%初始化一个最大值，和后面的数比较u = 0; v = 0;% 找一条最小边for i = [1 : N]for j = [1 : N]if vis(i) == 1 && vis(j) == 0if F(i, j) < minwminw = F(i, j);u = i; v = j;%记录最小边的顶点信息endendendend % 加入生成树vis(v) = 1;k = k+1;road(k, :) = [u v minw];% 打印本次选出的最小边路径和权值end2．运行窗口：在运行窗口输入：则输出：则输出：矩阵前两列表示顶点关系，最后一列表示权值。
【最新】prim算法实验报告-word范文模板 (12页)
本文部分内容来自网络整理，本司不为其真实性负责，如有异议或侵权请及时联系，本司将立即删除！== 本文为word格式，下载后可方便编辑和修改！ ==prim算法实验报告篇一：Prim算法实验报告算法实验报告学院：xxx班级：xxx学号：xxx姓名：xxx Prim篇二：Prim最小生成树算法实验报告算法分析与设计之Prim学院：软件学院学号：201X21031059 姓名：吕吕一、问题描述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; 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();1public:} void Prim();其中，图中结点连接情况及权值使用二重指针表示，即二维数组实现邻接矩阵。
最小生成树prim算法实现
最⼩⽣成树prim算法实现今天从志权师兄那⾥学会了最⼩⽣成树。
所谓⽣成树，就是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例题解释。
数据结构实验三,prim最小生成树
实验三：Prim最小生成树（验证性、4学时）一、实验目的和要求●理解图的遍历●理解构造无向联通图的最小生成树的方法（Prim算法实现）●能用Prim算法构造最小生成树出来二、实验内容和原理⑴实验内容：用Prim算法构造一颗最小生成树(2) 实验原理：①从网中任一顶点开始，先把该顶点包含在生成树中，此时生成树只有一个顶点。
②找出一个端点在生成树中另一端点在生成树外的所有边，并把权值最小的边连到同它所关联的另一个顶点添加到生成树中；当有两条及以上具有相同最小权值的边可供选择时，任选一条。
③反复执行②，直到所有顶点都包含在生成树时为止。
三、实验环境硬件：（1）学生用微机（2）多媒体教室或远程教学（3）局域网环境软件：（1）Windows XP中文操作系统（2）Turbo C四、算法描述及实验步骤1、描述从连通网中的某一定点开始，以此作为生成树的初始状态，然后不断地将网中的其他顶点添加到生成树上，知道最后一个顶点添加到生成树上是得到最小生成树。
一个无向连通网的生成树可能不是唯一的，当总代价一定是最小的。
2、算法流程图3、代码(注释)#include<>#include<>#include<>#include<>#define MAX_NAME 5#define MAX_VERTEX_NUM 20 /*权的上限值*/typedef char Vertex[MAX_NAME];/*顶点名字串*/typedef int AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];/*邻接距阵*/ struct MGraph/*定义图*/{ Vertex vexs[MAX_VERTEX_NUM];AdjMatrix arcs;int vexnum,arcnum; };typedef struct{ Vertex adjvex; /*当前点*/int lowcost; /*代价*/}minside[MAX_VERTEX_NUM];int LocateVex(MGraph G,Vertex u)owcost)i++;min=SZ[i].lowcost; /*将最小权值记在min中*/k=i; /*把与边关联的生成树外的顶点序号记在k中*/for(j=i+1;j<;j++)if(SZ[j].lowcost>0&&min>SZ[j].lowcost){ min=SZ[j].lowcost;k=j; }return k; }void MiniSpanTree_PRIM(MGraph G,Vertex u){ int i,j,k;minside closedge;k=LocateVex(G,u);for(j=0;j<;++j){ strcpy(closedge[j].adjvex,u);closedge[j].lowcost=[k][j]; }closedge[k].lowcost=0; /*将顶点vk加入生成树中*/printf("最小代价生成树的各条边为:\n");for(i=1;i<;++i){ k=minimum(closedge,G);printf("(%s-%s)\n",closedge[k].adjvex,[k]); /*输出最小边及权值*/ closedge[k].lowcost=0;for(j=0;j<;++j)if[k][j]<closedge[j].lowcost){ strcpy(closedge[j].adjvex,[k]);closedge[j].lowcost=[k][j]; } } } /*修改权值域*/int main(){ MGraph g;CreateGraph(g);MiniSpanTree_PRIM(g,[0]);system("PAUSE");return 0; }五、调试过程(1)没有定位（2）没有定义最小生成树（3）j的如何取值，循环没有六、实验结果（1）实验数据1实验结果1实验数据2实验结果2七、总结（1）理解用prim算法构造无向联通图的最小生成树的方法；（2）对于如何能够求得最小生成树加深了了解；（3）熟悉的prim算法的构造最小生成树的思路和方法；并且能够运用prim算法构造出最小生成树。
普里姆实验报告
一、实验目的1. 理解普里姆算法的基本原理和步骤。
2. 掌握使用C语言实现普里姆算法的方法。
3. 熟悉最小生成树的概念及其在实际应用中的重要性。
4. 通过实验验证普里姆算法的正确性和效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验原理普里姆算法是一种贪心算法，用于在加权无向图中寻找最小生成树。
最小生成树是指一个无向图的所有顶点构成的树，其边权值之和最小。
普里姆算法的基本思想是从某个顶点开始，逐步增加边，直到包含所有顶点为止。
四、实验步骤1. 定义邻接矩阵：首先定义一个二维数组表示图的邻接矩阵，其中元素表示两个顶点之间的边权值。
2. 初始化数据结构：定义一个结构体表示顶点，包含顶点的编号和距离。
初始化一个数组存储所有顶点的结构体。
3. 选择起始顶点：选择一个顶点作为起始顶点，将其距离设置为0，其余顶点的距离设置为无穷大。
4. 遍历邻接矩阵：对于每个顶点，遍历其邻接矩阵，找到距离最小的边，将其加入最小生成树中，并更新相邻顶点的距离。
5. 重复步骤4：重复步骤4，直到所有顶点都被加入最小生成树中。
6. 输出结果：输出最小生成树的边和权值。
五、实验代码```c#include <stdio.h>#include <stdlib.h>#define MAXVEX 6#define INF 10000typedef struct {int adjvex; // 邻接顶点的位置int lowcost; // 与adjvex顶点相连的边的权值} MinNode;typedef struct {char vexs[MAXVEX]; // 顶点表MinNode adjmatrix[MAXVEX][MAXVEX]; // 邻接矩阵int numVertexes, numEdges; // 图中当前顶点的数量和边的数量} MGraph;void CreateMGraph(MGraph G) {int i, j, k, w;printf("请输入顶点数量和边数量：\n");scanf("%d %d", &G->numVertexes, &G->numEdges);printf("请输入顶点信息：\n");for (i = 0; i < G->numVertexes; i++) {scanf("%s", G->vexs[i]);}for (i = 0; i < G->numVertexes; i++) {G->adjmatrix[i][j].adjvex = 0;G->adjmatrix[i][j].lowcost = INF;}}for (k = 0; k < G->numEdges; k++) {printf("请输入边(%d)的两个顶点和权值：\n", k + 1); scanf("%d %d %d", &i, &j, &w);G->adjmatrix[i][j].adjvex = j;G->adjmatrix[i][j].lowcost = w;G->adjmatrix[j][i].adjvex = i;G->adjmatrix[j][i].lowcost = w;}}void Prim(MGraph G, int u) {int min, i, j, k;MinNode adjvex;int visited[MAXVEX] = {0}; // 标记顶点是否被访问过visited[u] = 1;printf("%c ", G.vexs[u]); // 输出起始顶点for (i = 1; i < G.numVertexes; i++) {min = INF;k = u;if (visited[j] == 0 && G.adjmatrix[k][j].lowcost < min) { min = G.adjmatrix[k][j].lowcost;adjvex = G.adjmatrix[k][j];k = j;}}printf("%c ", G.vexs[k]); // 输出当前顶点visited[k] = 1;G.adjmatrix[u][k].lowcost = INF;G.adjmatrix[k][u].lowcost = INF;}}int main() {MGraph G;int u;printf("请输入起始顶点编号：\n");scanf("%d", &u);CreateMGraph(&G);Prim(G, u);return 0;}```六、实验结果1. 输入顶点数量和边数量：6 82. 输入顶点信息：A B C D E F3. 输入边(1)的两个顶点和权值：0 1 14. 输入边(2)的两个顶点和权值：0 2 25. 输入边(3)的两个顶点和权值：1 2 36. 输入边(4)的两个顶点和权值：1 3 67. 输入边(5)的两个顶点和权值：2 3 48. 输入边(6)的两个顶点和权值：2 4 59. 输入边(7)的两个顶点和权值：3 4 710. 输入边(8)的两个顶点和权值：4 5 811. 输入起始顶点编号：0实验结果：A B C D E F七、实验总结通过本次实验，我们成功实现了普里姆算法，并验证了其在实际应用中的有效性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《最小生成树(Prim算法)》算法演示程序设计说明
040648 范成
同济大学2004级计算机4班一、设计要求
题目：编写Prim算法的最小生成树程序，输出一个给定无向带权图的最小生成树。
二、设计思想
最小生成树的定义：
假设一个单位要在n个办公地点之间建立通信网，则连通n个地点只需要n-1条线路。
可以用连通的无向网来表示n个地点以及它们之间可能设置的通信线路，其中网的顶点表示城市，边表示两地间的线路，赋于边的权值表示相应的代价。
对于n个顶点的连通网可以建立许多不同的生成树，每一棵生成树都可以表示一个通信网。
其中一棵使总的耗费最少，即边的权值之和最小的生成树，称为最小生成树。
构造最小生成树可以用多种算法。
其中多数算法利用了最小生成树的下面一种简称为MST的性质：假设N=(V,{E})是一个连通网，U是顶点集V的一个非空子集。
若(u,v)是一条具有最小权值（代价）的边，其中u∈U，v∈V-U，则必存在一棵包含边 (u.v)的最小生成树。
普里姆（Prim）算法即是利用MST性质构造最小生成树的算法。
算法思想如下：
假设N=(V,{E})和是连通网，TE是N上最小生成树中边的集合。
算法从U={u0}( u0∈V)，TE={}开始，重复执行下述操作：在所有u∈U，v∈V-U的边(u, v) ∈E中找一条代价最小的边(u0, v0)并入集合TE，同时v0并入U，直到U=V为止。
此时TE中必有n-1条边，则T=(V,{TE})为N的最小生成树。
本程序中，采用图的邻接矩阵表示法，并使用二维数组表示网的邻接矩阵。
三、其他相关信息
开发平台：Microsoft V isual 2005 Professional
程序类型：Win32控制台应用程序
开发平台及程序运行截图：。