徐州工程学院数据结构最小生成树实验文档
最小生成树 实验报告
最小生成树实验报告最小生成树实验报告一、引言最小生成树是图论中的一个重要概念，它在实际问题中有着广泛的应用。
本次实验旨在通过编程实现最小生成树算法，并通过实验数据对算法进行分析和评估。
二、算法介绍最小生成树算法的目标是在给定的带权无向图中找到一棵生成树，使得树上所有边的权重之和最小。
本次实验我们选择了两种经典的最小生成树算法：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.在当前最小生成树的所有节点中选择一个与该树相连接的权重最小的边，将其加入最小生成树。
求最小生成树(Kruskal算法)实验报告
求最小生成树(Kruskal算法)实验报告一、实验目的通过本次实验，掌握Kruskal算法的基本原理，能够使用该算法求解最小生成树问题，并能够进行实际应用。
同时，为学习算法的设计和分析打下基础。
二、实验内容1. 理解Kruskal算法的基本原理。
2. 实现Kruskal算法，并将其应用于求解最小生成树问题。
3. 设计实验测试用例，验证程序正确性并进行性能分析。
三、实验原理Kruskal算法是最小生成树问题的一种解决方法。
该算法基于贪心策略，通过不断选择最短的边来构造最小生成树。
实现步骤如下：1. 将所有边按权重从小到大进行排序。
2. 遍历所有边，每次选择一条没有出现在生成树中的最短边，并将该边所连接的两个顶点合并到同一连通分量中。
3. 直到所有的边都被遍历过，即可得到最小生成树。
四、实验设计本次实验的主要任务是实现Kruskal算法，并运用到最小生成树问题中。
为了测试算法的正确性和性能，需要设计适当的测试用例。
具体的实验步骤如下：1. 设计数据结构在Kruskal算法中，需要维护边的信息，并对边进行排序，同时需要维护顶点的信息。
为方便实现，可以使用C++语言的STL库中的vector和set数据结构。
vector用于存储顶点信息，set用于存储排序后的边信息。
其中，顶点包含顶点编号和连通分量编号，边包含起点、终点和边权重。
为了方便生成测试数据，定义两个常量：MAX_VERTEX和MAX_EDGE。
MAX_VERTEX表示最大顶点数量，MAX_EDGE表示最大边数量。
2. 生成测试数据为了测试算法的正确性和性能，需要生成不同大小的测试数据。
可以随机生成若干个顶点和相应的边，其中顶点编号从1开始连续编号，边的起点和终点使用随机数生成，边的权重也使用随机数生成。
3. 实现Kruskal算法根据算法原理，可以实现基本的Kruskal算法。
具体实现过程如下：1. 首先将所有的边按照权重从小到大排序，并分别初始化每个顶点的连通分量编号。
最小生成树实验报告材料
数据结构课程设计报告题目：最小生成树问题院（系）：计算机工程学院学生姓名:班级：学号:起迄日期:指导教师:2011—2012年度第2 学期一、需求分析1.问题描述：在n个城市之间建设网络，只需保证连通即可，求最经济的架设方法。
存储结构采用多种。
求解算法多种。
2.基本功能在n个城市之间建设网络，只需要架设n-1条线路，建立最小生成树即可实现最经济的架设方法。
程序可利用克鲁斯卡尔算法或prim算法生成最小生成树。
3.输入输出以文本形式输出最小生成树，同时输出它们的权值。
通过人机对话方式即用户通过自行选择命令来输入数据和生成相应的数据结果。
二、概要设计1.设计思路：因为是最小生成树问题，所以采用了课本上介绍过的克鲁斯卡尔算法和prim算法两种方法来生成最小生成树。
根据要求，需采用多种存储结构，所以我选择采用了邻接表和邻接矩阵两种存储结构。
2.数据结构设计：图状结构：ADT Graph{数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。
数据关系R：R={VR}VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧，谓词P(v,w)定义了弧<v,w>的意义或信息}基本操作：CreateGraph( &G, V, VR )初始条件：V是图的顶点集，VR是图中弧的集合。
操作结果：按V和VR的定义构造图G。
DestroyGraph( &G )初始条件：图G存在。
操作结果：销毁图G。
LocateVex( G, u )初始条件：图G存在，u和G中顶点有相同特征。
操作结果：若G中存在顶点u，则返回该顶点在图中位置；否则返回其它信息。
GetVex( G, v )初始条件：图G存在，v是G中某个顶点。
操作结果：返回v的值。
PutVex( &G, v, value )初始条件：图G存在，v是G中某个顶点。
操作结果：对v赋值value。
FirstAdjVex( G, v )初始条件：图G存在，v是G中某个顶点。
徐州工程学院数据结构实验报告
徐州工程学院管理学院实验报告实验课程名称：数据结构与算法实验地点：经济管理实验中心年月至年月专业信息管理与信息系统班级学生姓名学号指导老师实验报告实验项目：线性表及其应用实验学时： 2实验日期：实验要求：熟悉并掌握单链表的存储及基本算法的使用实验内容：单链表就地逆置代码如下：#include<stdio.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;LNode *p106,*head106;LNode *s106,*l106,*d106;int n;int m=sizeof(LNode);void ListCreate(){int i106;head106=(LinkList)malloc(m);p106=head106;for(i106=1;i106<5;i106++){p106->data=i106;p106->next=(LinkList)malloc(m);p106=p106->next;}p106->data=5;p106->next=NULL;}void ListOutput(){p106=head106;while(p106->next!=NULL){printf("%d",p106->data);p106=p106->next;}printf("%d\n",p106->data);}void ListChange(){LNode *q106,*l106;p106=head106;l106=p106->next;while(l106!=NULL){q106=l106->next;l106->next=p106;p106=l106;l106=q106;}head106->next=NULL;head106=p106;}void ListFinal(){p106=head106;while(p106->next!=NULL){printf("%d",p106->data);p106=p106->next;}printf("%d\n",p106->data);}int main(){ListCreate();ListOutput();ListChange();ListFinal();getch();}运行结果如下：实验项目：栈的应用实验学时： 2实验日期：实验要求：熟悉并掌握利用栈的特性进行相关运算实验内容：：双向栈的应用代码如下：#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int Elemtype;typedef struct{ int *base[2]; int *top[2];}*BDStacktype;Init_BDStack(BDStacktype tws,int m)｛(*tws).base[0]=(Elemtype*)malloc(m*sizeof(Elemtype)); (*tws).base[1]=(*tws).base[0]+((m-1)*sizeof(Elemtype)); (*tws).top[0]=(*tws).base[0];(*tws).top[1]=(*tws).base[1];return OK;}push(BDStacktype tws,int i106,Elemtype x) {if((*tws).top[0]>(*tws).top[1]) return OVERFLOW;if(i106==0) *(*tws).top[0]++=x;else if(i106==1){ if((*tws).top[1]==(*tws).base[1]) return OVERFLOW;*x=*++(*tws).top[1];}else return ERROR;return OK; }printBDStack(BDStacktype tws)｛Elemtype *p;p=(*tws).base[0];printf("Now the 0 Stack is:");Elemtype *p;p=(*tws).base[0];printf("Now the 0 Stack is:");while(p!=(*tws).top[0])printf("%d",*p++);printf("\n");p=(*tws).base[1];printf("Now the 1 Stack is:");while(p!=(*tws).top[1])printf("%d",*p--);printf("\n");}void main(){int m=0; int t=0,n;Elemtype *e; int i106;BDStacktype s;printf("Input the size of BDStack :");scanf("%d",m);Init_BDStack(s,m);printf("Input the total num of push:");scanf("%d",&t);for(i106=1;i106<t+1;i106++){printf("Input the %dth stack No.and data of push:",i);scanf("%d,%d",&n,e);push(s,n,*e); }printBDStack(s);printf("Input the stack No. which you will pop:");scanf("%d",&n);pop(s,n,e);printf("Pop the %dth stack,the num is:%d\n",n,*e);printBDStack(s);printf("\n");getch();}(2)结果实验项目：数组的应用实验学时：4实验日期：实验要求：熟悉并掌握矩阵压缩存储的算法实验内容：矩阵压缩存储代码如下：#include<stdlib.h>typedef int ElemType;#define MAXSIZE 100typedef struct{int i,j;ElemType e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu106,nu,tu;}TSMatrix;int CreateSMatrix(TSMatrix *M){int i,m,n;ElemType e;int k;printf("hang,lie,feiling geshu:\n");scanf("%d,%d,%d",&(*M).mu106,&(*M).nu,&(*M).tu);(*M).data[0].i=0;for(i = 1; i <= (*M).tu; i++){do{printf("%dgefeilingyuansuozaide hang(1-%d), lie(1-%d),yuansuzhi:\n", i,(*M).mu106,(*M).nu);scanf("%d,%d,%d",&m,&n,&e);k=0;if(m < 1 || m > (*M).mu106|| n < 1 || n > (*M).nu)k=1;if(m <(*M).data[i-1].i || m ==(*M).data[i-1].i && n <= (*M).data[i-1].j) k=1;}while(k);(*M).data[i].i = m;(*M).data[i].j = n;(*M).data[i].e = e;}(*M).data[i].i = m;(*M).data[i].j = n;(*M).data[i].e = e;}return 1;}void PrintSMatrix(TSMatrix M){int x,y,z;int k;for(x=1;x<=M.mu106;x++){for(y=1;y<=M.nu;y++){k=0;for(z=1;z<=M.tu;z++){if((M.data[z].i==x) && (M.data[z].j==y)){ printf("%4d",M.data[z].e);k=1;}}if(k==0){printf("%4d",k);}}printf("\n");}}int main(){TSMatrix A;CreateSMatrix(&A);PrintSMatrix(A);getch();}（2）结果：实验项目：树的应用实验学时：2实验日期：实验要求：熟悉并掌握建立树及利用二叉树遍历算法进行其他操作实验内容：二叉树的叶子结点计算代码如下：#include "stdio.h"#include "conio.h"typedef struct Node{char data;struct Node *lchild,*rchild;}BiTNode;crt_bt_pre106(){BiTNode *T;char ch;printf("ch==");scanf("%c",&ch);if(ch==' ')T=NULL;else{T=(BiTNode*) malloc (sizeof(BiTNode));T->data=ch;T->lchild=crt_bt_pre106(T->lchild);T->rchild=crt_bt_pre106(T->rchild);}return T;}void preorder106 (BiTNode *T){if(T!=NULL){printf("%c",T->data);preorder106(T->lchild);preorder106(T->rchild);}}int leafCount106(BiTNode *T){if(!T) return 0;else if (!T->lchild && !T->rchild) return 1;else return leafCount106(T->lchild) + leafCount106(T->rchild); }void main(){BiTNode *root;printf("creat erchashu:");root=crt_bt_pre106();printf("\n");printf("preorder:");printf("\n");preorder106(root);printf("\n");printf("count is %d\n",leafCount106(root));getch();}(2)结果：实验项目：图的应用实验学时：2实验日期：实验要求：熟悉并掌握图的构造算法的使用实验内容：有向图的邻接表存储代码如下：#include "stdio.h"typedef struct e_node{ int adjvex;struct e_node *next ;}E_NODE;E_NODE *q106;E_NODE *p106;typedef struct v_node{ int vertex;E_NODE *link;}V_NODE;V_NODE head[20];void creat_adj_list(V_NODE head[], int t, int n) {int i106;int e106;int w106;int v106;w106=1,v106=1;for(i106=1;i106<=n;i106++){ head[i106].link=NULL;head[i106].vertex=i106;}printf("the sidenumber is: e=");scanf("%d",&e106);for(i106=1;i106<=e106;i106++){printf("v=");scanf("%d",&v106);printf("w=");scanf("%d",&w106);if((v106<=n)&&(w106<=n)){if(t==1){p106=(E_NODE *)malloc(sizeof(E_NODE));p106->adjvex=w106;p106->next=head[v106].link;head[v106].link=p106;}if(t==0){ p106=(E_NODE *)malloc(sizeof(E_NODE));p106->adjvex=v106;p106->next=head[w106].link;head[w106].link=p106;}}}printf("the content : \n");for(i106=1;i106<=n;i106++){q106=head[i106].link;printf("the number %d vertex =>",i106); while(q106!=NULL){printf("%d",q106->adjvex);q106=q106->link;}printf("\n");}}void main(){int t;int n;printf("t=");scanf("%d",&t);printf("the number of vertex :");scanf("%d",&n);creat_adj_list(head,t,n);getch();}结果:实验项目：查找和排序算法应用实验学时： 4实验日期：实验要求：熟悉并掌握查找和排序算法的使用实验内容：对某字符串进行排序，并在此基础上利用查找算法进行查找代码如下：#include "stdio.h"typedef struct {char key;}create;create st[26];void build(){printf("please input the letters:");gets(st);}void change(){int t106;int i106;int j106;for(j106=0;j106<25;j106++){for(i106=0;i106<25-j106;i106++){if(st[i106].key>st[i106+1].key){t106=st[i106].key;st[i106].key=st[i106+1].key;st[i106+1].key=t106;}}}printf("the right order is:");for(i106=0;i106<26;i106++){printf("%c",st[i106]);}}int binsrch(create st[],char k){int low,high,mid, found;low=0; high=25; found=0;while((low<=high) &&(found==0)){mid=(low+high)/2;if(k>st[mid].key) low=mid+1;else if(k==st[mid].key) found=1; else high=mid-1;}if(found==1) return(mid);else return(-1);}int main(){int n;char k;build();change();printf("\nthe letter needed found is:"); scanf("%c",&k);n=binsrch(st,k);printf("the location is: %d",n+1);getch();}（2）结果：。
最小生成树实验报告
最小生成树实验报告最小生成树实验报告引言：最小生成树是图论中一个重要的概念，它在许多实际问题中都有广泛的应用。
本次实验旨在通过实际操作，深入理解最小生成树的概念、算法及其在实际问题中的应用。
本文将从实验的目的、实验过程、实验结果及分析等方面进行详细的论述。
实验目的：1. 理解最小生成树的概念及其在实际问题中的应用；2. 掌握最小生成树的两种常用算法：Prim算法和Kruskal算法；3. 通过实际操作，加深对最小生成树算法的理解。
实验过程：1. 实验环境的搭建：首先，我们需要在计算机上搭建一个图论实验环境。
选择一门编程语言，如Python，来实现最小生成树算法。
通过安装相应的开发环境和图论库，我们可以方便地进行实验。
2. 数据的准备：为了进行最小生成树的实验，我们需要准备一组具有权值的图数据。
可以通过手动输入或从文件中读取的方式获取数据。
确保数据的合理性和完整性，以便进行后续的实验操作。
3. Prim算法的实现：Prim算法是一种贪心算法，用于求解最小生成树。
在实验中，我们需要实现Prim算法，并将其应用于准备好的图数据上。
通过编程实现，我们可以得到Prim算法生成的最小生成树。
4. Kruskal算法的实现：Kruskal算法是另一种常用的最小生成树算法。
与Prim算法不同，Kruskal算法是一种基于边的贪心算法。
同样地，我们需要实现Kruskal算法，并将其应用于准备好的图数据上，以获得Kruskal算法生成的最小生成树。
实验结果与分析：通过实验，我们得到了Prim算法和Kruskal算法生成的最小生成树。
我们可以将这两个结果进行对比和分析，以进一步理解这两种算法的特点和应用场景。
首先，我们可以比较两个算法生成的最小生成树的权值。
通过计算权值的总和，我们可以确定哪个算法生成的最小生成树更优。
此外，我们还可以比较两个算法生成的最小生成树的结构，观察它们是否存在差异。
其次，我们可以分析两个算法的时间复杂度和空间复杂度。
数据结构实验指导书及答案(徐州工程学院)
《数据结构实验》实验指导书及答案信电工程学院计算机科学和技术教研室编2011.12数据结构实验所有代码整理作者郑涛声明：在这里我整理了数据结构实验的所有代码，希望能对大家的数据结构实验的考试有所帮助，大家可以有选择地浏览，特别针对一些重点知识需要加强记忆（ps:重点知识最好让孙天凯给出），希望大家能够在数据结构实验的考试中取得令人满意的成绩，如果有做的不好的地方请大家谅解并欢迎予以指正。
实验一熟悉编程环境实验预备知识：1．熟悉本课程的语言编译环境（TC或VC），能够用C语言编写完整的程序，并能够发现和改正错误。
2．能够灵活的编写C程序，并能够熟练输入C程序。
一、实验目的1．熟悉C语言编译环境，掌握C程序的编写、编译、运行和调试过程。
2．能够熟练的将C程序存储到指定位置。
二、实验环境⒈硬件：每个学生需配备计算机一台。
⒉软件：Windows操作系统+Turbo C；三、实验要求1．将实验中每个功能用一个函数实现。
2．每个输入前要有输入提示（如：请输入2个整数当中用空格分割：），每个输出数据都要求有内容说明（如：280和100的和是：380。
）。
3．函数名称和变量名称等用英文或英文简写（每个单词第一个字母大写）形式说明。
四、实验内容1．在自己的U盘中建立“姓名+学号”文件夹，并在该文件夹中创建“实验1”文件夹（以后每次实验分别创建对应的文件夹），本次实验的所有程序和数据都要求存储到本文件夹中（以后实验都按照本次要求）。
2．编写一个输入某个学生10门课程成绩的函数（10门课程成绩放到结构体数组中，结构体包括：课程编号，课程名称，课程成绩）。
3．编写一个求10门成绩中最高成绩的函数，输出最高成绩和对应的课程名称，如果有多个最高成绩，则每个最高成绩均输出。
4．编写一个求10门成绩平均成绩的函数。
5．编写函数求出比平均成绩高的所有课程及成绩。
#include<stdio.h>#include<conio.h>struct subject{int subject_id;char subject_name[20];double subject_grades;};struct subject sub[10];void input(){int i;printf("please input:\n");for(i=0;i<10;i++){scanf("%d %s %lf",&sub[i].subject_id,&sub[i].subject_name,&sub[i].subject_g rades);}printf("you just input:\n");for(i=0;i<3;i++){printf("%d %s %lf\n",sub[i].subject_id,sub[i].subject_name,sub[i].subject_g rades);}}void subject_max(){int i,flag;double max=sub[0].subject_grades;for(i=0;i<10;i++){if(sub[i].subject_grades>max)max=sub[i].subject_grades;flag=i;}printf("The high score of subjectis %s %lf\n",sub[flag].subject_name,max);}void subject_average(){int i;double average,sum=sub[0].subject_grades;for(i=1;i<10;i++){sum+=sub[i].subject_grades;}average=sum/10;printf("subject's average is %lf\n",average);}void subjct_gtaverage(){int i,flag;double average,sum=sub[0].subject_grades;for(i=1;i<10;i++){sum+=sub[i].subject_grades;}average=sum/10;for(i=0;i<10;i++){if(sub[i].subject_grades>average){flag=i;printf("subject greater than average is %s %lf\n",sub[flag].subject_name,sub[flag].subject_grades);}}}int main(){input();subject_max();subject_average();subjct_gtaverage();return 0;}实验二顺序表的基本操作实验预备知识：1．熟练运用数组进行程序设计，掌握数组名和指针作为函数参数。
数据结构实验报告-最小生成树（精选5篇）
数据结构实验报告-最小生成树（精选5篇）第一篇：数据结构实验报告-最小生成树电子科技大学实验报告学生姓名：XXX 学号：20***指导教师：刘峤实验地点：信软楼306实验时间：5月17日一、实验室名称：软件实验室二、实验项目名称：数据结构与算法—图三、实验学时：4四、实验原理：Kruskal 算法是一种按照图中边的权值递增的顺序构造最小生成树的方法。
其基本思想是：设无向连通网为G＝（V，E），令G 的最小生成树为T，其初态为T＝（V，{}），即开始时，最小生成树T 由图G 中的n 个顶点构成，顶点之间没有一条边，这样T 中各顶点各自构成一个连通分量。
然后，按照边的权值由小到大的顺序，考察G 的边集E 中的各条边。
若被考察的边的两个顶点属于T 的两个不同的连通分量，则将此边作为最小生成树的边加入到T 中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T 中的连通分量个数为1 时，此连通分量便为G 的一棵最小生成树。
如教材153页的图4.21(a)所示，按照Kruskal 方法构造最小生成树的过程如图4.21 所示。
在构造过程中，按照网中边的权值由小到大的顺序，不断选取当前未被选取的边集中权值最小的边。
依据生成树的概念，n 个结点的生成树，有n－1 条边，故反复上述过程，直到选取了n－1 条边为止，就构成了一棵最小生成树。
五、实验目的：本实验通过实现最小生成树的算法，使学生理解图的数据结构存储表示，并能理解最小生成树Kruskal 算法。
通过练习，加强对算法的理解，提高编程能力。
六、实验内容：（1）假定每对顶点表示图的一条边，每条边对应一个权值；（2）输入每条边的顶点和权值；（3）输入每条边后，计算出最小生成树；（4）打印最小生成树边的顶点及权值。
七、实验器材（设备、元器件）：八、数据结构及程序#include #include #include typedefstruct {intvex;intgno;}TVex,*TpVex;typedefstruct {intvhead, vtail;intwght;intflag;}TEdge,*TpEdge;typedef struct{TpVex VexList;TpEdge EdgeList;int nvex, nedge;}TGraph, *TpGraph;void begin(TpGraph G){ int i;for(i=1;i<=G->nvex;i++){G->VexList[i-1].gno=i;G->EdgeList[i-1].flag=0;} } int findmin(TpGraph G){ int i,j;int minwght=G->EdgeList[0].wght;for(i=0,j=-1;inedge;i++){ PC机一台，装有C/C++语言集成开发环境。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验九图的最小生成树算法的实现实验预备知识：1．理解图最小生成树的意义和相应算法。
2．掌握带权图的存储结构。
一、实验目的1．使学生熟悉最小生成树的算法实现。
2．掌握带权图的存储结构和处理方法。
二、实验环境⒈硬件：每个学生需配备计算机一台。
操作系统：DOS或Windows；⒉软件：DOS或Windows操作系统+Turbo C；三、实验要求1．能够独立完成带权图的存储和最小生成树的生成四、实验内容1．在自己的U盘的“姓名+学号”文件夹中创建“实验9”文件夹，本次实验的所有程序和数据都要求存储到本文件夹中。
2．现在某电信公司要对如下图的几个城市之间进行光纤连接布线，请用合适的存储结构将下图存储到计算机中方便进行处理。
3．现在公司想以最小的代价将所有城市连通，方便所有城市间通信，请用普里姆算法和克鲁斯卡尔算法实现本图的最小生成树#include <stdio.h>#include <stdlib.h>#define INF 50typedef struct ArcNode{int adjvex; //该弧所指向的顶点位置struct ArcNode *nextarc; //下一个临接点int weight; //弧的权重}ArcNode; //表结点typedef struct VNode{char data; //顶点信息ArcNode *firstarc; //指向下一个结点}VNode,AdjList[6];typedef struct{AdjList LH; //创建头结点数组int vexnum; //图的点的个数int arcnum; //图的边的个数}Graph;typedef struct{char nextvex;int lowcost;int know;}Auxiliary_array; //辅助数组结构体void main (void){void buildtu (Graph*);void printgraph(Graph*);void prim( Graph *G, char u);char u;Graph UDG;Graph *G = &UDG;buildtu(G);printgraph(G); //打印图printf("请输入起始顶点：\n");while(getchar()!='\n');u = getchar();prim(G ,u);}void buildtu (Graph *G) { //建图int search(Graph *G,char a);int i,n1,n2,w;char a,b;ArcNode *p, *q;printf("请输入顶点个数和边的条数：\n");scanf("%d %d",&G->vexnum,&G->arcnum);printf("请输入顶点信息\n");for (i = 0; i < G->vexnum; ++i){while (getchar()!='\n');scanf("%c",&G->LH[i].data);G->LH[i].firstarc = NULL;}printf("请输入有关系的结点和该边的权重:\n");for(i=0;i<G->arcnum;++i){while (getchar()!='\n');scanf("%c %c %d",&a,&b,&w);n1=search(G,a);n2=search(G,b);p=G->LH[n1].firstarc;if(p == NULL){p=G->LH[n1].firstarc=(ArcNode *) malloc (sizeof(ArcNode));}else{while( p->nextarc !=NULL ){p=p->nextarc;}p=p->nextarc=(ArcNode *) malloc (sizeof(ArcNode));}q=G->LH[n2].firstarc;if(q == NULL){q=G->LH[n2].firstarc=(ArcNode *) malloc (sizeof(ArcNode));}else{while( q->nextarc !=NULL ){q=q->nextarc;}q=q->nextarc=(ArcNode *) malloc (sizeof(ArcNode));}p->adjvex=n2;p->weight=w;p->nextarc=NULL;q->adjvex=n1;q->weight=w;q->nextarc=NULL;}}int search (Graph *G,char a){ //确定顶点a在头结点数组中的位置int i;for(i=0;i<G->vexnum;++i){if(G->LH[i].data==a){return i;}}}void printgraph(Graph *G){ //打印图int i;ArcNode *p;for (i=0 ; i < G->vexnum; ++i){p=G->LH[i].firstarc;printf("data:%c \t",G->LH[i].data);while(p!=NULL){printf("firstarc->adjvex=%d",p->adjvex);p=p->nextarc;}printf("\n");}}void prim( Graph *G, char u){//用prim算法实现最小生成树int search (Graph *G,char a);int minimize(Graph *G, Auxiliary_array[]);void printtable(Auxiliary_array[]);Auxiliary_array A[6]; //创建辅助数组int i,j,seat;int location;ArcNode *p ;for (i = 0; i < G->vexnum; ++i) {A[i].nextvex = '0';A[i].know= 0;A[i].lowcost = INF;}location = search(G ,u);//确定u元素在头结点数组中的位置for (p=G->LH[location].firstarc ; p != NULL; p=p->nextarc ){i = p->adjvex;A[i].nextvex = G->LH[location].data;A[i].lowcost = p->weight;A[i].know= 0;}A[location].know = 1;A[location].lowcost = 0;A[location].nextvex = '0';for(j=0;j<G->vexnum-1;++j){seat = minimize( G,A );printf("select min: %d\n", seat);A[seat].know = 1;p=G->LH[seat].firstarc;for (p; p != NULL; p=p->nextarc){i=p->adjvex;if(A[i].know == 0 && p->weight < A[i].lowcost){A[i].nextvex = G->LH[seat].data;A[i].lowcost = p->weight;}}}printtable(A); //打印辅助数组中的信息for (j = 0; j < G->vexnum; ++j)if (j != location)printf("%c<---->%c\n",A[j].nextvex,G->LH[j].data);}int minimize(Graph *G, Auxiliary_array A[]){//取出辅助数组中权值最小的顶点所在的位置int i,place,num;num = INF;for (i = 0; i < G->vexnum; ++i){if(A[i].know == 0 && num >= A[i].lowcost){num = A[i].lowcost;place = i;}}return place;}void printtable(Auxiliary_array A[]) {//打印辅助数组int i;for (i = 0; i < 6; i++) {printf("modifier:%c lowcost:%d known:%d\n", A[i].nextvex, A[i].lowcost, A[i].know);}}实验总结：通过该实验，我深刻明白到了自己对循环的能力不足，书写代码的逻辑性也不够强，相信在以后的学习中能加强这方面的学习，争取在以后的学习中解决这两个方面的问题。