数据结构实验五 图子系统
数据结构实验———图实验报告
数据结构实验报告目的要求１．掌握图的存储思想及其存储实现..２．掌握图的深度、广度优先遍历算法思想及其程序实现..３．掌握图的常见应用算法的思想及其程序实现..实验内容１．键盘输入数据;建立一个有向图的邻接表..２．输出该邻接表..3．在有向图的邻接表的基础上计算各顶点的度;并输出..4．以有向图的邻接表为基础实现输出它的拓扑排序序列..5．采用邻接表存储实现无向图的深度优先递归遍历..6．采用邻接表存储实现无向图的广度优先遍历..7．在主函数中设计一个简单的菜单;分别调试上述算法..源程序：主程序的头文件：队列#include <stdio.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int QElemType;typedef struct QNode{ //队的操作QElemType data;struct QNode *next;}QNode;*QueuePtr;typedef struct {QueuePtr front;QueuePtr rear;}LinkQueue;void InitQueueLinkQueue &Q{ //初始化队列Q.front =Q.rear =QueuePtrmallocsizeofQNode;ifQ.front exitOVERFLOW; //存储分配失败Q.front ->next =NULL;}int EnQueueLinkQueue &Q;QElemType e //插入元素e为Q的新的队尾元素{QueuePtr p;p=QueuePtrmallocsizeofQNode;ifp exitOVERFLOW;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear =p;return OK;}int DeQueueLinkQueue &Q;QElemType &e //删除Q的队头元素;用e返回其值{ ifQ.front ==Q.rear return ERROR;QueuePtr p;p=Q.front ->next;e=p->data;Q.front->next=p->next ;ifQ.rear==p Q.rear =Q.front ;freep;return OK;}主程序：#include <stdio.h>#include<stdlib.h>#include"duilie.h"#define TRUE 1#define FALSE 0#define Status int#define MAX_VERTEX_NUM 8 /*顶点最大个数*/#define VertexType char /*顶点元素类型*/enum BOOlean {False;True};BOOlean visitedMAX_VERTEX_NUM; //全局变量——访问标志数组typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;int weight; /*边的权*/}ArcNode; /*表结点*/typedef struct VNode{ int degree;indegree;/*顶点的度;入度*/V ertexType data;ArcNode *firstarc;}VNode/*头结点*/;AdjListMAX_VERTEX_NUM;typedef struct{ AdjList vertices;int vexnum;arcnum;/*顶点的实际数;边的实际数*/}ALGraph;//建立图的邻接表void creat_linkALGraph *G{ int i;j;ArcNode *s;printf"请依次输入顶点数、边数：";scanf"%d%d";&G->vexnum;&G->arcnum;for i=0;i<G->vexnum;i++{ G->verticesi.data='A'+i;G->verticesi.firstarc=NULL;}for i=0;i<G->vexnum;{ printf"请输入顶点的数组坐标若退出;请输入-1：";scanf"%d";&i;ifi==-1 break;printf"请输入顶点所指向下一个顶点的数组坐标：";scanf"%d";&j;s=ArcNode *mallocsizeofArcNode;s->adjvex=j;s->nextarc=G->verticesi.firstarc;G->verticesi.firstarc=s;}}// 输出邻接表void visitALGraph G{ int i;ArcNode *p;printf"%4s%6s%18s\n";"NO";"data";"adjvexs of arcs";for i=0;i<G.vexnum;i++{printf"%4d%5c ";i;G.verticesi.data;forp=G.verticesi.firstarc;p;p=p->nextarcprintf"%3d";p->adjvex;printf"\n";}}// 计算各顶点的度及入度void cacuALGraph *G{ArcNode *p;int i;for i=0;i<G->vexnum;i++{G->verticesi.degree=0;G->verticesi.indegree=0;}//度与初度初始化为零for i=0;i<G->vexnum;i++forp=G->verticesi.firstarc;p;p=p->nextarc{G->verticesi.degree++;G->verticesp->adjvex.degree++;G->verticesp->adjvex.indegree++;}}void print_degreeALGraph G{int i;printf"\n Nom data degree indegree\n";for i=0;i<G.vexnum;i++printf"\n%4d%5c%7d%8d";i;G.verticesi.data;G.verticesi.degree;G.verticesi.indegree;printf"\n";}// 拓扑排序Status TopologiSortALGraph G{int i;count;top=0;stack50;ArcNode *p;cacu&G;print_degreeG;printf"\nTopologiSort is \n";fori=0;i<G.vexnum;i++ifG.verticesi.indegree stacktop++=i;count=0;whiletop=0{i=stack--top;if count==0 printf"%c";G.verticesi.data;else printf"-->%c";G.verticesi.data;count++;forp=G.verticesi.firstarc;p;p=p->nextarcif --G.verticesp->adjvex.indegreestacktop++=p->adjvex;}if count<G.vexnumreturnFALSE; else returnTRUE;}//在图G中寻找第v个顶点的第一个邻接顶点int FirstAdjVexALGraph G;int v{ifG.verticesv.firstarc return 0;else returnG.verticesv.firstarc->adjvex;}//在图G中寻找第v个顶点的相对于u的下一个邻接顶点int NextAdjVexALGraph G;int v;int u{ArcNode *p;p=G.verticesv.firstarc;whilep->adjvex=u p=p->nextarc; //在顶点v的弧链中找到顶点u ifp->nextarc==NULL return 0; //若已是最后一个顶点;返回0else returnp->nextarc->adjvex; //返回下一个邻接顶点的序号}//采用邻接表存储实现无向图的深度优先递归遍历void DFSALGraph G;int i{ int w;visitedi=True; //访问第i个顶点printf"%d->";i;forw=FirstAdjVexG;i;w;w=NextAdjVexG;i;wifvisitedw DFSG;w; //对尚未访问的邻接顶点w调用DFS}void DFSTraverseALGraph G{ int i;printf"DFSTraverse:";fori=0;i<G.vexnum;i++ visitedi=False; //访问标志数组初始化fori=0;i<G.vexnum;i++ifvisitedi DFSG;i; //对尚未访问的顶点调用DFS}//按广度优先非递归的遍历图G;使用辅助队列Q和访问标志数组visited void BFSTraverseALGraph G{int i;u;w;LinkQueue Q;printf"BFSTreverse:";fori=0;i<G.vexnum;i++ visitedi=False; //访问标志数组初始化InitQueueQ; //初始化队列fori=0;i<G.vexnum;i++ifvisitedi{visitedi=True; //访问顶点iprintf"%d->";i;EnQueueQ;i; //将序号i入队列whileQ.front ==Q.rear //若队列不空;继续{DeQueueQ;u; //将队头元素出队列并置为uforw=FirstAdjVexG;u;w;w=NextAdjV exG;u;wifvisitedw //对u的尚未访问的邻接顶点w进行访问并入队列{ visitedw=True;printf"%d->";w;EnQueueQ;w;}}}}void main{ALGraph G;int select;printf" 图的有关操作实验\n ";do{printf"\n1 创建一个有向图的邻接表 2 输出该邻接表\n";printf"3.输出该有向图的度和入度 4.输出该有向图拓扑排序序列\n";printf"5.创建一个无向图的邻接表 6.深度优先递归遍历该无向图\n";printf"7.广度优先遍历该无向图0.退出\n";printf"请输入选择：";scanf"%d";&select;switchselect{case 1:printf"\n创建一个有向图的邻接表：\n";creat_link&G;break;case 2:printf"\n输出该邻接表：\n";visitG;break;case 3:printf"\n输出该有向图的度和入度：\n";cacu&G;print_degreeG;break;case 4:printf"\n输出该有向图拓扑排序序列：\n";ifTopologiSortGprintf"Toposort is not success";break;case 5:printf"\n创建一个无向图的邻接表: \n";creat_link&G;break;case 6:printf"\n深度优先递归遍历该无向图: \n";DFSTraverseG;break;case 7:printf"\n广度优先遍历该无向图：\n";BFSTraverseG;break;case 0:break;default:printf"输入选项错误重新输入\n";}}whileselect;}运行结果截图：1.主菜单界面：2.创建一个有向图的领接表3.输出该邻接表4. 在有向图的邻接表的基础上计算各顶点的度;并输出..5. 输出它的拓扑排序序列6. 输出所建无向图的邻接表7. 深度优先递归遍历该无向图8. 广度优先遍历该无向图说明：本实验用的有向图是课本182页图7.28;无向图为课本168页图a实验总结这次的图的操作实验;与树的操作类似;但又比树复杂;包含更多的存储结构和遍历方法的操作;而且图的遍历需要沿着弧进行;以便输出弧上的信息..本实验中图的遍历采用邻接表的存储结构;在输入图的信息时;首先要画出图的邻接表信息..图有两种遍历的形式;一种为深度优先搜索;另一种为广度优先搜索..由于能力有限;没能实现图的深度非递归优先搜索;而是实现了图的深度递归优先搜索..本实验基本完成了图的操作;也学到了很多关于图的知识和算法..。
数据结构-实验5-图的应用
实验报告
开课学院及实验室: 年月日
五实验方法
1 对问题进展需求分析, 选取详细城市结点, 通过调研获取城市间的交通网络, 选取主要的通行道路抽象为图的无向带权边。
2 进展概要设计和详细设计, 形成模块间的调用构造图和模块的算法。
3 编写程序, 设计测试用例进展测试。
4 完成开发文档。
六实验结果
1需求分析: 在中国城市, 电子地图的认知度和使用率正在飞快递增, 随着用户量不断增加, 纸质地图逐渐被电子地图取而代之。
在大中型城市, 电子地图已经成为绝大多数用户出行前首选的参照工具和查询途径。
电子地图强调准确性、简单易用以及查询速度。
电子地图的另外一个特点是使用方便, 无论是通过互联网还是手机都可以方便接触到并使用。
出行前用电脑通过互联网地图规划道路、查找目的地, 路上那么可以用手机连接无线网络, 通过手机地图随时修正道路和辨识方向。
2概要设计:
3详细设计:
4编程遇到的问题和调试分析:
5用户手册:
概述: 简单的交通咨询系统
功能:
1.珠三角地区交通查询；
2.珠三角地区各城市信息查询。
使用说明:
1.翻开方法: 翻开命令行窗口, 进入map.exe文件所在目录〔如: cd e:/map〕, 输入map, 进入程序。
2.构造地图信息, 按提示输入map.txt.
3.交通查询功能的使用: 输入1进入查询, 按要求输入起点城市编号和终点城市编号, 回车即可。
4.城市信息查询功能的使用：输入2进入查询, 按要求输入城市编号, 回车即可。
6 测试结果:
7 附录〔源程序清单〕。
数据结构试验报告-图的基本操作
中原工学院《数据结构》实验报告学院：计算机学院专业：计算机科学与技术班级：计科112姓名：康岩岩学号：201100814220 指导老师：高艳霞2012-11-22实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。
2、熟练掌握图的存储结构。
3、熟练掌握图的两种遍历算法。
二、实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。
[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
【测试数据】由学生依据软件工程的测试技术自己确定。
三、实验前的准备工作1、掌握图的相关概念。
2、掌握图的逻辑结构和存储结构。
3、掌握图的两种遍历算法的实现。
四、实验报告要求1、实验报告要按照实验报告格式规范书写。
2、实验上要写出多批测试数据的运行结果。
3、结合运行结果，对程序进行分析。
【设计思路】【代码整理】#include "stdafx.h"#include <iostream>#include <malloc.h>using namespace std;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW -1#define MAX_SIZE 20typedef enum{DG,DN,UDG,UDN}Kind;typedef struct ArcNode{int adjvex; //顶点位置struct ArcNode *nextarc; //下一条弧int *info; //弧信息};typedef struct{char info[10]; //顶点信息ArcNode *fistarc; //指向第一条弧}VNode,AdjList[MAX_SIZE];typedef struct{AdjList vertices;int vexnum,arcnum; //顶点数，弧数int kind; //图的种类，此为无向图}ALGraph;//这是队列的节点，仅用于广度优先搜索typedef struct Node{int num;struct Node* next;};//队列的头和尾typedef struct{Node * front;Node *rear;}PreBit;int LocateV ex(ALGraph G,char info[]);//定位顶点的位置Status addArcNode(ALGraph &G,int adjvex); //图中加入弧Status CreatGraph(ALGraph&G);//创建图的邻接表Status DFSTraverse(ALGraph G);//深度优先搜索Status BFSTraverse(ALGraph G);//广度优先搜索Status DFS(ALGraph G,int v);//深度优先搜索中的数据读取函数，用于递归bool visited[MAX_SIZE]; // 访问标志数组//初始化队列Status init_q(PreBit&P_B){P_B.front=P_B.rear=(Node*)malloc(sizeof(Node));if(!P_B.front){exit(OVERFLOW);}P_B.front->next=NULL;}//将数据入队Status en_q(PreBit & P_B,int num){Node *p=(Node*)malloc(sizeof(Node));if(!p){exit(OVERFLOW);}p->num=num;p->next=NULL;P_B.rear->next=p;P_B.rear=p;return OK;}//出队Status de_q(PreBit & P_B){if(P_B.front==P_B.rear){return ERROR;}Node* p=P_B.front->next;P_B.front->next=p->next;if(P_B.rear==p){P_B.rear=P_B.front;}free(p);return OK;}Status CreatGraph(ALGraph&G){cout<<"请输入顶点数目和弧数目"<<endl;cin>>G.vexnum>>G.arcnum;//依次输入顶点信息for(int i=0;i<G.vexnum;i++){cout<<"请输入顶点名称"<<endl;cin>>G.vertices[i].info;G.vertices[i].fistarc=NULL;}//依次输入弧信息for(int k=1;k<=G.arcnum;k++){char v1[10],v2[10]; //用于表示顶点名称的字符数组int i,j; //表示两个顶点的位置BACK: //返回点cout<<"请输入第"<<k<<"条弧的两个顶点"<<endl;cin>>v1>>v2;i=LocateV ex(G,v1); //得到顶点v1的位置j=LocateV ex(G,v2); //得到顶点v2的位置if(i==-1||j==-1){ //头信息不存在则返回重输cout<<"不存在该节点!"<<endl;goto BACK; //跳到BACK 返回点}addArcNode(G,i); //将弧的顶点信息插入表中addArcNode(G,j);}return OK;}//倒序插入弧的顶点信息Status addArcNode(ALGraph &G,int adjvex){ArcNode *p; //弧节点指针p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=adjvex;p->nextarc=G.vertices[adjvex].fistarc;//指向头结点的第一条弧G.vertices[adjvex].fistarc=p; //头结点的第一条弧指向p，即将p作为头结点的第一条弧return OK;}//定位顶点的位置int LocateV ex(ALGraph G,char info[]){for(int i=0;i<G.vexnum;i++){if(strcmp(G.vertices[i].info,info)==0){ //头结点名称与传入的信息相等，证明该头节点存在return i; //此时返回位置}}return -1;}//深度优先搜索Status DFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int i;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;i=LocateV ex(G,v1);if(i==-1){cout<<"不存在该节点!"<<endl;goto BACK;}DFS(G,i);return OK;}//深度优先搜索递归访问图Status DFS(ALGraph G,int v){visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息ArcNode *p;p=G.vertices[v].fistarc; //向头节点第一条while(p) //当弧存在{if(!visited[p->adjvex]){DFS(G,p->adjvex); //递归读取}p=p->nextarc;}return OK;}//广度优先搜索Status BFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int v;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;v=LocateV ex(G,v1);if(v==-1){cout<<"不存在该节点!"<<endl;goto BACK;}PreBit P_B;init_q(P_B);ArcNode *p;visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息en_q(P_B,v); //将头位置v入队while(P_B.front!=P_B.rear){//当队列不为空时，对其进行访问int w=P_B.front->next->num;//读出顶点位置de_q(P_B);//顶点已经访问过，将其出队列p=G.vertices[w].fistarc;//得到与顶点相关的第一条弧while(p){if(!visited[p->adjvex]){en_q(P_B,p->adjvex);//将弧入队，但不读取，只是将其放在队尾}p=p->nextarc;}}return OK;}int _tmain(int argc, _TCHAR* argv[]){ALGraph G;CreatGraph(G);cout<<"深度优先搜索图:"<<endl;DFSTraverse(G);cout<<endl;cout<<"广度优先搜索图:"<<endl;BFSTraverse(G);cout<<endl;system("pause");return 0;}。
查找子系统(1)
《数据结构》实验报告实验名称：查找子系统日期：XXXX 年XX月xx日得分：指导老师：XX专业：XXXX 班次：XXXX班姓名：xxx 学号：XXXXXXXXXXX1. 实验内容：编写顺序查找、二分查找程序(二选一)；编写建立二义排序树的程序；编写在二义排序树上的查找、插入、删除结点的程序；编写二义排序树中序输出的程序(选做)；设计一个选择式菜单。
2. 实验要求：通过查找实验理解查找的基本算法；熟悉各种查找方法的适用场合及平■均查找长度；掌握静态查找和动态查找的区别；掌握顺序查找、二分查找的基本思想及其算法；掌握二义排序树基本思想及其算法。
3. 程序代码：#include<stdio.h>#include<string.h>#define SEARCHMAX 100#define N 10void SeqSearch(){int a[N],i,x,y;char ch;printf("\n\t\t 建立一个整数的顺序表(以回车符为间隔，以-1结束)：\n");for(i=0;i<SEARCHMAX;i++){printf("\t\t");scanf("%d”,&a[i]);getchar();if(a[i]==-1){y=i;break;}}printf("\n\t\t 需要查找请输入Y,否则输入N：”);scanf("%c”,&ch);while(ch=='y'||ch=='Y'){printf("\n\t\t 请输入要查找的数据：");scanf("%d”,&x);getchar();i=y-1;while(i>=0&&a[i]!=x)i--;if(i==-1)printf("\n\t\t 抱歉！没有您要查找的数据。
数据结构数据结构单元5 图
数据结构
（3）路径长度 路径长度定义为该路径上边的数目。 （4）简单路径 若一条路径除两端顶点可以相同外，其余顶点均不相 同，则称此路径为一条简单路径。 （5）回路 起点和终点相同的路径称为回路。 （6）简单回路或简单环 起点和终点相同的简单路径称为简单回路或简单环。 （7）有根图和图的根 在一个有向图中，若存在一个顶点v，从该顶点有路 径可以到达图中其它所有顶点，则称此有向图为有根图， v称作图的根。
17
单元5 图
数据结构
（2）头结点结构 5-8的无向图的邻接表如图5-10。 【示例】图 顶点vi邻接表的头结点包含两个域
图5-2无向图G1
2
单元5 图
4
数据结构
2．无向图和有向图 （1）无向图（Undirected Graph） 若图G中的每条边都是没有方向的，则称G为无向图。 无向图中边的表示：无向图中的边均是顶点的无序对，无序 对通常用圆括号表示，无序对(vi,vj)和(vj,vi) 表示图中的同 一条边。 （2）有向图（Directed Graph） 若图G中的每条边都是有方向的，则称G为有向图。有 向图中边的表示：有向图中的边是由顶点的有序对组成，有 序对通常用尖括号表示，有序对<vi,vj>和<vj,vi> 表示的是 图中不同的边。有向边也称为弧，边的始点称为弧尾，终点 称为弧头。
【示例】网络的邻接矩阵如图5-9。
9 B 5 3 A 4 6 C 7
9 A6 3 9 4 5 6 4 7 3 5 7 7 8
D
8
E
图5-9 网络的邻接矩阵表示
单元5 图
14
数据结构
做 一 做
【课堂实践5-1】 分别写出图5-2的无向图G1和图5-2的有向图G2 的邻接矩阵。
国家开放大学《数据结构》课程实验报告(实验5——图的存储方式和应用)参考答案
scanf("%d%d",&i,&j);
GA[i][j]=GA[j][i]=1;
}
}
else if(k1==0 && k2!=0) /*建立无向有权图*/
{
printf("输入%d条无向有权边的起点和终点序号及权值！\n",e);
for(k=1; k<=e; k++)
{
scanf("%d%d%d",&i,&j,&w);
printf("输入待处理图的顶点数和边数：");
scanf("%d%d",&n,&e);
/*输入有无向选择和有无权选择*/
printf("输入有无向选择和有无权选择（0为无，非0为有）：");
scanf("%d%d",&k1,&k2);
CreateMatrix(gv,ga,n,e,k1,k2); /*建立图的邻接矩阵*/
printf("%6s","∞");
else
printf("%6d",GA[i][j]);
}
printf("\n");
}
}
实验结果：
测试用例1无向无权图如下图所示。
程序运行结果如下：
测试用例2有向有权图如下图所示。
程序运行结果如下：
实
验
小
结
（1）具有n个顶点的图，其邻接矩阵为n×n阶方阵，用二维数组存储，行列下标为0～n-1。
{
int i,j;
printf("顶点");
实验六 图及其应用
实验六图及其应用数据结构实验六图及其应用1、实验目的? 熟练掌握图的两种存储结构(邻接矩阵和邻接表)的表示方法 ? 掌握图的基本运算及应用? 加深对图的理解，逐步培养解决实际问题的编程能力2、实验内容：采用邻接表或邻接矩阵方式存储图，实现图的深度遍历和广度遍历；用广度优先搜索方法找出从一顶点到另一顶点边数最少的路径。
1．问题描述：利用邻接表存储结构，设计一种图（有向或无向），并能够对其进行如下操作：1) 创建一个可以随机确定结点数和弧（有向或无向）数的图; 2) 根据图结点的序号，得到该结点的值；3) 根据图结点的位置的第一个邻接顶点的序号，以及下一个邻接顶点的序号;4) 实现从第v 个顶点出发对图进行深度优先递归遍历; 5) 实现对图作深度优先遍历;6) 实现对图进行广度优先非递归遍历; 编写主程序，实现对各不同的算法调用。
2．实现要求：（以邻接表存储形式为例）编写图的基本操作函数:：对图的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要从时间复杂度和空间复杂度上进行评价。
1)“建立图的邻接表算法”：CreateGraph(ALGraph *G) 操作结果：采用邻接表存储结构,构造没有相关信息的图G2)“邻接表表示的图的递归深度优先遍历算法”：DFSTraverse(ALGraphG,void(*Visit)(char*)) 初始条件：图G 已经存在；操作结果：返回图的按深度遍历的结果。
3)“邻接表表示的图的广度优先遍历算法”： BFSTraverse(ALGraphG,void(*Visit)(char*)) 初始条件：图G 已经存在；操作结果：返回图的按广度遍历的结果。
4)“邻接表从某个结点开始的广度优先遍历算法”：BFS(ALGraph G, int v)初始条件：图G 已经存在；操作结果：返回图从某个结点开始的按广度遍历的结果。
分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
数据结构实验4：队列子系统
验证性实验4：队列子系统班级学号 20 姓名施程程得分1．实验目的（1）掌握队列的特点及其描述方法。
（2）用链式结构实现一个队列。
（3）掌握队列的各种基本操作。
（4）掌握队列的简单应用程序。
2．实验内容（1）设计一个字符型的链队列。
（2）编写队列的进队、出队、读队头元素、显示队列中全部元素程序。
（3）设计一个输入限制性的双队列，要求：输入只能在一端进行，而输出可以选择从队头输出或队尾输出，全部选择完毕后能显示所选择的输出结果。
设计一个选择式菜单，以菜单方式选择队列的各种基本操作。
菜单形式如下：队列子系统**************************************************** 1------------进队 ** 2------------出队 ** 3------------读队头元素 ** 4------------显示 ** 5------------双队列 ** 0------------退出 ****************************************************请选择菜单号（0--5）：3．实验程序#include<stdio.h>typedef struct queuenode{int data;struct queuenode *next;}QueueNode;typedef struct{QueueNode *front,*rear;}LinkQueue;void InQueue(LinkQueue *q){int x;QueueNode *p=new QueueNode;printf("\n\t\t请键入一个整数：");scanf("%d",&x);getchar();p->data=x;p->next=NULL;if(q->front==NULL)q->front=p;elseq->rear->next=p;q->rear=p;if(p)printf("\n\t\t%d进队成功！",x); }int OutQueue(LinkQueue *q,int *v){QueueNode *p;if(q->front==NULL)return 0;else{p=q->front;*v=p->data;q->front=p->next;if(q->front==NULL)q->rear=NULL;delete p;return 1;}}void ShowQueue(LinkQueue *q){QueueNode *p=q->front;if(p==NULL)printf("\n\t\t队列为空！\n");else{printf("\n\t\t队列中的元素为：");while(p!=NULL){printf("%6d",p->data);p=p->next;}printf("\n");}}void ReadFront(LinkQueue *q){if(q==NULL||q->front==NULL)printf("\n\t\t队列为空！没有对顶元素！\n");elseprintf("\n\t\t队首元素是：%4d\n",q->front->data); }#define QUEUEMAX 20int queue[QUEUEMAX];int front=-1;int rear=-1;void InQueue(int val){rear=(rear++)%QUEUEMAX;if(front==rear)printf("\n\t\t队列已满！");elsequeue[rear]=val;}int OutQueue_rear(){int t;if(front==rear)return -1;t=queue[rear--];if(rear<0&&front!=-1)rear=QUEUEMAX-1;return t;}int OutQueue_front(){int t;if(front==rear)return -1;elset=queue[++front];if(front==QUEUEMAX)front=0;return t;}void DQ(){int choice;int out[5];int in[5]={5,4,3,2,1};int t,pos=0,i;for(i=0;i<5;i++)InQueue(in[i]);printf("\n\t\t初始数据顺序是：");for(i=0;i<5;i++)printf("[%d] ",in[i]);printf("\n\t\t 1------从头出队 2------从尾出队\n\n");while(front!=rear){printf("\t\t请输入选择（1 或 2）：");scanf("%d",&choice);switch(choice){case 1:t=OutQueue_front();out[pos++]=t;break;case 2:t=OutQueue_rear();out[pos++]=t;break;}}printf("\n\t\t数据输出的顺序是：");for(i=0;i<5;i++)printf("[%d] ",out[i]);printf("\n");getchar();}void main(){LinkQueue *q=new LinkQueue;int val,i=1;char w,choice;q->front=q->rear=NULL;while(i){printf("\n");printf("\n\t\t 队列子系统 ");printf("\n\t\t***************************************************");printf("\n\t\t* 1------------进队 *");printf("\n\t\t* 2------------出队 *");printf("\n\t\t* 3------------读队头元素 *");printf("\n\t\t* 4------------显示 *");printf("\n\t\t* 5------------双队列 *");printf("\n\t\t* 0------------退出 *");printf("\n\t\t***************************************************");printf("\n\t\t 请选择菜单号（0--5）：");scanf("%c",&choice);getchar();switch(choice){case '1':InQueue(q);break;case '2':if(OutQueue(q,&val)==0)printf("\n\t\t队列为空！\n");elseprintf("\n\t\t出队元素为：%d",val);break;case '3':ReadFront(q);break;case '4':ShowQueue(q);break;case '5':DQ();break;case '0':i=0;break;default:;}if(choice=='1'||choice=='2'||choice=='3'||choice=='4'||choice=='5'){printf("\n\n\t\t按【Enter】键继续，按任意键返回主菜单，\n");w=getchar();if(w!='\xA')i=0;}}}4．程序运行5．实验小结本章主要要求我们掌握的队列的特点及其描述方法也就是队列的进队、出对等。
数据结构实验报告图的存储
数据结构实验报告图的存储数据结构图实验报告一、实验目的和要求（1）掌握图的相关概念，包括图，有向图，无向图，完全图，子图，连通图，度，入度，出度，简单回路和环等定义。
（2）重点掌握图的各种存储结构，包括邻接矩阵和邻接表等。
（3）重点掌握图的基本运算，包括创建图，输出图，深度优先遍历，广度优先遍历等。
（4）掌握图的其他运算，包括最小生成树，最短路径，拓扑排序和关键路径等算法。
（5）灵活运用图这种数据结构解决一些综合应用问题。
二、实验内容和方法(1)实验内容：1、编写一个程序algo8-1.cpp，实现不带权图和带权图的邻接矩阵与邻接表的相互转换算法、输出邻接矩阵与邻接表的算法，并在此基础上设计一个程序exp8-1.cpp实现如下功能：①建立如图1所示的有向图G的邻接矩阵，并输出；②由有向图G的邻接矩阵产生邻接表，并输出；③再由②的邻接表产生对应的邻接矩阵，并输出。
图12、编写一个程序algo8-2.cpp，实现图的遍历运算，并在此基础上设计一个程序exp8-2.cpp完成如下功能：①输出图1所示的有向图G从顶点0开始的深度优先遍历序列（递归算法）；②输出图1所示的有向图G从顶点0开始的深度优先遍历序列（非递归算法）；③输出图1所示的有向图G从顶点0开始的广度优先遍历序列。
3、设计一个程序exp8-3.cpp,采用邻接表存储图，并输出图8.1（a）中从指定顶点1出发的所有深度优先遍历序列。
(2)实验方法：1、综合运用课本所学的知识，用不同的算法实现在不同的程序功能。
2、结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。
3、根据实验内容，编译程序。
三、实验环境：Windows 7，Visual C++6.0三、实验过程描述文件graph.h中定义了图的邻接矩阵表示类型和邻接表表示类型，该头文件在以下三个实验中都会使用到。
其代码如下：#ifndef GRAPH_H_INCLUDED#define GRAPH_H_INCLUDEDtypedef int InfoType;#define MAXV 100 //最大顶点个数#define INF 32767 //INF表示无限大//以下定义邻接矩阵类型typedef struct{int no;InfoType info;}VertexType;typedef struct{int edges[MAXV][MAXV];int n,e;VertexType vexs[MAXV];}MGraph;//以下定义邻接表类型typedef struct ANode{int adjvex;struct ANode* nextarc;InfoType info;}ArcNode;typedef int Vertex;typedef struct VNode{Vertex data;实验①源程序。
数据结构课程设计题目汇总及要求
数据结构课程设计题目课程设计题一：线性表子系统一．设计目的：1.掌握线性表的特点2.掌握线性表的顺序存储结构和链式存储结构的基本运算3.掌握线性表的基本操作二．设计内容和要求：1.设计一个选择式菜单。
线性表子系统******************************************************* 1 ……建表** 2 ……插入** 3 ……删除** 4 ……显示** 5 ……查找** 6 ……求表长** 0 ……返回*******************************************************请选择菜单号（0…6）：2.采用单链表创建线性表。
3.在线性表中实现插入、删除元素，显示线性表中所有元素，查找元素和求线性表长的基本操作。
课程设计题二：栈子系统一．设计目的：1.掌握栈的特点及其描述方法2.掌握链式存储结构实现一个栈3.掌握链栈的各种基本操作4.掌握栈的典型应用的算法二．设计内容和要求：1.设计一个选择式菜单。
栈子系统****************************************************** * 1 ……入栈* * 2 ……出栈* * 3 ……显示* * 4 ……数制转换* * 0 ……返回* ****************************************************** 请选择菜单号（0…4）：2.设计一个整型数据元素的链栈。
3.编写入栈、出栈和显示栈中全部元素的程序。
4.编写一个把十进制数转换成八进制数的应用程序。
课程设计题三：队列子系统一．设计目的：1.掌握队列的特点及其描述方法2.掌握链式存储结构实现一个队列3.掌握队列的各种基本操作4.掌握队列简单应用的算法二．设计内容和要求：1.设计一个选择式菜单。
队列子系统******************************************************* 1 ……入队** 2 ……出队** 3 ……读队首元素** 4 ……显示** 5 ……报数问题** 0 ……退出*******************************************************请选择菜单号（0…5）：2.设计一个整型数据元素的链队列。
数据结构：图子系统
/**题目：编写按键盘输入的数据建立图的邻接矩阵存储*编写图的深度优先遍历程序*编写图的广度优先遍历程序*设计一个选择式菜单形式如下：*图子系统**************************************1------更新邻接矩阵***2------深度优先遍历***3------广度优先遍历***0------返回**************************************请选择菜单号（ 0--3）：*/#include <stdio.h>#include <stdlib.h>#define GRAPHMAX 30#define QUEUEMAX 30typedef struct// 图的邻接表的结构体{char value[GRAPHMAX];// 记录图中的点值int data[GRAPHMAX][GRAPHMAX];// 记录图中的边的关系int n, e;// 记录图中的点的个数及边的个数}pGraph;typedef struct// 队列结构体{int queueData[QUEUEMAX];int front, rear, count;// 队头，队尾，数目}grQueue;void createCraph(pGraph *G);void DFSTraverse(pGraph *G);void BFSTraverse(pGraph *G);void DFS(pGraph *G, int i);void BFS(pGraph *G, int i);void initQueue(grQueue *Q);int queueEmpty(grQueue *Q);int queueFull(grQueue *Q);int outQueue(grQueue *Q);void inQueue(grQueue *Q, int i);int visited[GRAPHMAX];// 用于标志性的数组（全局变量）void main(){pGraph G;int choice, i, j, k = 1;printf(" 建立一个有向图的邻接矩阵表示createCraph(&G);\n");printf("已建立一个图的邻接矩阵存储\n\n");for (i = 0; i<G.n; i++){for(j = 0; j<G.n; j++){printf("%5d", G.data[i][j]);}printf("\n");}while (k){printf("\n图子系统 \n");printf("***********************************\n");printf("* printf("* printf("* printf("*1------ 更新邻接矩阵2------ 深度优先遍历3------ 广度优先遍历0------返回*\n");*\n");*\n");*\n");printf("***********************************\n");printf(" 请选择菜单号（ fflush(stdin);scanf("%d", &choice);0--3）： ");switch(choice){case 1:createCraph(&G);printf(" 图的邻接矩阵存储成功break;case 2:\n\n");DFSTraverse(&G);break;case 3:BFSTraverse(&G);break;case 0:k = 0;break;default:printf(" 输入错误，请重新输入。
考研数据结构5 图
vertex firstedge
ivex
ilink jvex
jlink
(a) 顶点表结点
(b) 边表结点
图 6-21 邻接多重表的结点结构
v1
v2
v3
v4
v5
(a) 无向图
v1 v2 v3 v4 ∧ v5
0
1
2
1
4
1∧
0 ∧3∧
2
3
2 ∧1∧
(b) 邻接多重表存储示意图 图 6-22 无向图的邻接多重表存储示意图
10
DotNetWalker 计算机考研资料 - 图解数据结构
in
vertex firstedge
图 6-38 拓扑排序算法中邻接表的顶点表结点
A
B
C
D
E
F
in vertex firstedge
03A ∧
10B
0
21C
0
33D
0
40E
2
52F ∧
3∧ 3∧ 5∧ 3
(a) 一个 AOV 网
(b) AOV 网的邻接表存储示意图
①
v1
②
v2
③⑥
⑤
v3
v4
④
(a) 一个有向图
v1 从顶点 v1 出发
v4
v2
v3
v3
v3
v1
v1
v1
v1
v1
v1
①
②
③
④
⑤
⑥
(b) 有向图深度优先遍历过程中栈的变化
图 6-10 有向图的深度优先遍历路线及栈的变化示意图
遍历结束
v6
v1
v2
出队
各子系统的数据流程图及数据字典
．系统内部框架及数据字典1.1 信息分类及相互关系中国人民大学图书馆信息系统是围绕学校图书馆的各项业务活动而建立的,其中涉及的信息大体上可以分为四类：业务过程信息、读者信息、费用信息和管理信息。
其中业务过程信息是指完成业务所产生的过程控制信息，如借阅信息、书刊出入库信息等，都是局部信息；读者信息是指在读者整个在校期间需要在整个系统范围内共享的信息，是基本信息；管理信息是由基本信息和业务过程信息加工得到的,如读者流动情况、书刊平均借阅天数、效率分析等，是派生信息.读者借阅活动和各类信息之间的关系1.2 贯穿系统的两条信息线集成各局部系统的重要目标是确保整个系统不随着局部系统的改变而改变，不随着新系统的加入而发生大的变化。
找出图书馆信息系统的内在联系，确立好各局部系统之间的接口，是实现这一目标的前提。
贯穿整个图书馆信息系统有两条信息线:读者信息线和费用信息线。
以此为框架来构造和集成整个系统。
证件信息包括读者主索引、借阅记录等等；费用信息包括在各个环节发生的各类费用及消耗成本等。
这两条信息线在系统中体现为具体的数据结构，它独立于各局部系统而存在。
从整体的、发展的角度来构筑好这一基础框架是本系统数据结构的核心.2. 各子系统的数据流程图及数据字典2．1财务管理子系统功能：负责全馆财务、物资采购及发放、安全保卫及卫生清洁等工作.其中财务管理包括：全馆人员工资、奖金发放及经费管理。
流程: 罚款收据读者ID 结算数据罚单单 据 务 整工资报表 会计凭证采购计划预算数据 会计凭证现金额 财务调整 财务调整资金采购资料批准/不批准审批准/送进计划 行 政 科 采 访 科读 者支付罚款 应收款项 单据处理应付款项 职 工 支付工资支付款 项 证件 检查 证件调整需配置及初始化的表：字段中文名称字段名类型长度说明业务号 TRAD_NO I 20 发生业务的统一编号 日期 TRAD_DATE D 业务发生的日期 收入 INCOME I 30 业务收入的金额 支出 OUTCOME I 30 业务的支出凭证号 PROOF_NO C 10 本项业务涉及的凭证的编号 摘要CHIEF_INTRC50业务内容的摘要2 功能：组织和管理藏书.组织和管理藏书：根据藏书的不同类型、内容、性质和使用价值进行合理的组织编目、科学的分类,根据借阅的需求拟更新藏书建议目录，负责馆藏剔旧处理，根据实际情况及时更新书刊信息；流程：现金审批通过的项目 拨款额 预算项目 财务状况 预 支预 额 算 工作 财务 报 数量表 财务调整采 计 图书处理更新计划 购 划领款通知采购图书会计凭证图书处理 发票开支费用各类图书分类图书处理更新旧图书资料 财务状况主管部门采访部 行政科 下达 预算 财务科 开单据 整合 账单 考核审批分类 统计核算 上报处理调 整上报 图书库分类清理清理核算需配置及初始化的表：字段中文名称 字段名 类型 长度 说明编号 BOOK_NO C 16 全馆书刊的统一编号，可作为识别标志 书名 BOOK_NAME C 50 书刊名称 作者 WRI_NAME C 10 作者的姓名 出版社 PUB_HOUSE C 50 出版社的名称 出版日期 PUB_DATE D 本版的出版日期 版次 PUB_TIMES I 4类别 BOOK_VAR C 20 按本馆图书的分类方法分类 借阅者 REA_NO C 8 读者的标志号 库存地点SAVE_PLACEI16用户定义的完整性约束要求类别和借阅者的填入值必须有效，即必须是存在的值。
实验五 图基本操作的实现
实验五图基本操作的实现【实验课程名称】数据结构【实验项目名称】单链表基本操作的实现【实验目的】1 理解图的存储结构；2掌握邻接矩阵储存结构的图基本操作；3学会设计实验数据验证程序。
【实验仪器及环境】计算机，window xp操作系统，VC++6.0【实验内容及步骤】1．图的基本操作const INFINITY = INT_MAX; // 最大值∞const MAX_VERTEX_NUM = 20;// 最大顶点个数typedef enum {DG, DN, AG, AN} GraphKind;// 类型标志{有向图,有向网,无向图,无向网} typedef struct ArcCell { // 弧的定义VRType adj; // VRType是顶点关系类型。
对无权图，用1或0//表示相邻否；对带权图，则为权值类型。
InfoType *info; // 该弧相关信息的指针} AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct { // 图的定义VertexType vexs[MAX_VERTEX_NUM]; // 顶点信息AdjMatrix arcs; // 表示顶点之间关系的二维数组int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志2. 实现的基本操作：CreateGraph(&G, V, VR);初始条件：V 是图的顶点集，VR 是图中弧的集合。
操作结果：按V 和VR 的定义构造图G。
DesstroyGraph(&G);初始条件：图G 存在。
操作结果：销毁图G。
LocateVex(G, u);初始条件：图G 存在，u 和G 中顶点有相同特征。
操作结果：若G 中存在和u 相同的顶点，则返回该顶点在图中位置；否则返回其它信息。
GetVex(G, v);初始条件：图G 存在，v 是G 中某个顶点。
数据结构实验报告 图
数据结构实验报告图一、实验目的本次实验的主要目的是深入理解和掌握图这种数据结构的基本概念、存储结构和相关算法，并通过实际编程实现来提高对图的操作和应用能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容（一）图的存储结构1、邻接矩阵邻接矩阵是用一个二维数组来表示图中顶点之间的关系。
如果顶点i 和顶点 j 之间有边相连，则数组中对应的元素值为 1；否则为 0。
这种存储结构简单直观，适用于顶点数较少且边数较多的稠密图。
2、邻接表邻接表是为图的每个顶点建立一个单链表，链表中存储的是与该顶点相邻的顶点信息。
这种存储结构在存储空间上比较节省，适用于顶点数较多且边数较少的稀疏图。
（二）图的遍历算法1、深度优先遍历（DepthFirst Search，简称 DFS）从图中的某个顶点出发，沿着一条路径尽可能深地访问顶点，直到无法继续前进，然后回溯到上一个未完全访问的顶点，继续进行深度优先搜索。
2、广度优先遍历（BreadthFirst Search，简称 BFS）从图中的某个顶点出发，先访问其所有相邻的顶点，然后再依次访问这些相邻顶点的相邻顶点，以此类推，逐层向外扩展。
（三）图的最短路径算法1、迪杰斯特拉（Dijkstra）算法用于求解单源最短路径问题，即从一个给定的源顶点到图中其他所有顶点的最短路径。
2、弗洛伊德（Floyd）算法用于求解任意两个顶点之间的最短路径。
四、实验步骤（一）邻接矩阵的实现｀｀｀cppinclude ＜iostream>using namespace std;const int MAX_VERTEX_NUM ＝ 100;class Graph ｛private:int vertexNum;int edgeNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;edgeNum ＝ 0;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ 0;｝｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ 1;adjMatrixji ＝ 1;edgeNum+＋；｝｝void printGraph(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛cout ＜＜ adjMatrixij ＜＜＂＂；｝cout ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gprintGraph(）；return 0;｝｀｀｀（二）邻接表的实现｀｀｀cppinclude ＜iostream>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void printGraph(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛cout ＜＜ i ＜＜＂：＂；for （int j ＝ 0; j ＜ adjListisize(）； j+＋）｛cout ＜＜ adjListij ＜＜＂＂；｝cout ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gprintGraph(）；return 0;｝｀｀｀（三）深度优先遍历的实现｀｀｀cppinclude ＜iostream>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100;class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM;bool visitedMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛visitedi ＝ false;｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void DFS(int v) ｛visitedv ＝ true;cout ＜＜ v ＜＜＂＂；for （int i ＝ 0; i ＜ adjListvsize(）； i+＋）｛int u ＝ adjListvi;if （！visitedu) ｛DFS(u)；｝｝｝void DFSTraversal(）｛for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv) ｛DFS(v)；｝｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gDFSTraversal(）；return 0;｝｀｀｀（四）广度优先遍历的实现｀｀｀cppinclude ＜iostream>include ＜queue>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; class Graph ｛private:int vertexNum;vector<int> adjListMAX_VERTEX_NUM; bool visitedMAX_VERTEX_NUM; public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛visitedi ＝ false;｝｝void addEdge(int i, int j) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjListipush_back(j)；adjListjpush_back(i)；｝｝void BFS(int v) ｛queue<int> q;visitedv ＝ true;qpush(v)；while （！qempty(））｛int u ＝ qfront(）；qpop(）；cout ＜＜ u ＜＜＂＂；for （int i ＝ 0; i ＜ adjListusize(）； i+＋）｛int w ＝ adjListui;if （！visitedw) ｛visitedw ＝ true;qpush(w)；｝｝｝｝void BFSTraversal(）｛for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv) ｛BFS(v)；｝｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1)；gaddEdge(0, 2)；gaddEdge(1, 2)；gaddEdge(2, 3)；gaddEdge(3, 4)；gBFSTraversal(）；return 0;｝｀｀｀（五）迪杰斯特拉算法的实现｀｀｀cppinclude ＜iostream>include ＜climits>include ＜vector>using namespace std;const int MAX_VERTEX_NUM ＝ 100; const int INFINITY ＝ INT_MAX; class Graph ｛private:int vertexNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;int distanceMAX_VERTEX_NUM;bool visitedMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ INFINITY;｝distancei ＝ INFINITY;visitedi ＝ false;｝｝void addEdge(int i, int j, int weight) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ weight;adjMatrixji ＝ weight;｝｝int minDistance(）｛int min ＝ INFINITY;int minIndex ＝－1;for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv ＆＆ distancev ＜＝ min) ｛min ＝ distancev;minIndex ＝ v;｝｝return minIndex;｝void dijkstra(int src) ｛distancesrc ＝ 0;for （int count ＝ 0; count ＜ vertexNum 1; count+＋）｛int u ＝ minDistance(）；visitedu ＝ true;for （int v ＝ 0; v ＜ vertexNum; v+＋）｛if （！visitedv ＆＆ adjMatrixuv!＝ INFINITY ＆＆ distanceu!＝INFINITY ＆＆ distanceu ＋ adjMatrixuv ＜ distancev) ｛distancev ＝ distanceu ＋ adjMatrixuv;｝｝｝for （int i ＝ 0; i ＜ vertexNum; i+＋）｛cout ＜＜＂源点＂＜＜ src ＜＜＂到顶点＂＜＜ i ＜＜＂的最短距离为: ＂＜＜ distancei ＜＜ endl;｝｝｝；int main(）｛Graph g(5)；gaddEdge(0, 1, 2)；gaddEdge(0, 2, 4)；gaddEdge(1, 2, 1)；gaddEdge(1, 3, 7)；gaddEdge(2, 3, 3)；gaddEdge(3, 4, 5)；gdijkstra(0)；return 0;｝｀｀｀（六）弗洛伊德算法的实现｀｀｀cppinclude ＜iostream>include ＜climits>using namespace std;const int MAX_VERTEX_NUM ＝ 100; const int INFINITY ＝ INT_MAX; class Graph ｛private:int vertexNum;int adjMatrixMAX_VERTEX_NUMMAX_VERTEX_NUM;int distanceMAX_VERTEX_NUMMAX_VERTEX_NUM;public:Graph(int vNum) ｛vertexNum ＝ vNum;for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛adjMatrixij ＝ INFINITY;｝｝｝void addEdge(int i, int j, int weight) ｛if （i ＞＝ 0 ＆＆ i ＜ vertexNum ＆＆ j ＞＝ 0 ＆＆ j ＜ vertexNum) ｛adjMatrixij ＝ weight;｝｝void floyd(）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛distanceij ＝ adjMatrixij;｝｝for （int k ＝ 0; k ＜ vertexNum; k+＋）｛for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛if （distanceik!＝ INFINITY ＆＆ distancekj!＝ INFINITY ＆＆distanceik ＋ distancekj ＜ distanceij) ｛distanceij ＝ distanceik ＋ distancekj;｝｝｝｝for （int i ＝ 0; i ＜ vertexNum; i+＋）｛for （int j ＝ 0; j ＜ vertexNum; j+＋）｛if （distanceij ＝＝ INFINITY) ｛cout ＜＜＂顶点＂＜＜ i ＜＜＂到顶点＂＜＜ j ＜＜＂的距离为: 无穷大" ＜＜ endl;｝ else ｛cout ＜＜＂顶点＂＜＜ i ＜＜＂到顶点＂＜＜ j ＜＜＂的距离为: ＂＜＜ distanceij ＜＜ endl;｝｝｝｝｝；int main(）｛Graph g(4)；gaddEdge(0, 1, 5)；gaddEdge(0, 3, 10)；gaddEdge(1, 2, 3)；gaddEdge(2, 3, 1)；gfloyd(）；return 0;｝｀｀｀五、实验结果分析（一）邻接矩阵和邻接表的比较邻接矩阵的优点是可以快速判断两个顶点之间是否有边相连，时间复杂度为O(1)。
数据结构实验五图子系统
数据结构实验五图子系统实验五实验题目:图子系统指导老师:王春红专业班级:计算机科学与技术系1105班姓名:李慧2011100521杜丽20111005122白莹2011100523王媛20111005292013年 5月23日实验类型综合实验室_软件实验室一__一、实验题目1图子系统二、实验目的和要求,(掌握图的存储思想及其存储实现,(掌握图的深度、广度优先遍历算法思想及其程序实现,(掌握图的常见应用算法的思想及其程序实现。
三、实验内容实验内容二:所有顶点对的最短路径1(设置4个村庄之间的交通，村庄之间的距离用各边上的权值来表示。
现在要求从这4个村庄中选择一个村庄建一所医院，问这所医院应建在哪个村庄，才能使离医院最远的村庄到医院最近。
2(设计分析用有向加权图表示的交通图中，有向边<vi,vj>表示第i个村庄和第j个村庄之间有道路，边上的权表示这条道路的长度。
该问题的实质是求解任意两顶点间的最短路径问题。
即求出每个顶点到其他顶点的最短路径的最大值，最大值最小的顶点作为医院所在村庄。
3(结构类型定义typedef char vextype;/*顶点数据类型*/typedef int edgetype;/*边数据类型*/typedef struct{vextype vex[maxsize];edgetype arc[maxsize][maxsize];int vexnum,arcnum;}Mgraph;小组分工:组长:王媛定义结构体和主函数组员:李慧 void juzhen(Mgraph *G)白莹、杜丽void panduan(Mgraph *G)四、实验步骤程序如下:#include <stdio.h>#include <malloc.h>#define max 100#define min 0typedef int edgetype;typedef char vextype;typedef struct2{vextype ver[4];edgetype edge[4][4];int edgenum,vernum; }Mgraph;void juzhen(Mgraph *G) {int i,j;printf("四个村庄的邻接矩阵为:\n"); for(i=0;i<4;i++)for(j=0;j<4;j++)scanf("%d",&G->edge[i][j]);}void panduan(Mgraph *G) {int a[4],b[4],c[4];int i,j,t,t2,p,q,n,k;for(i=0;i<4;i++){a[0]=0;a[1]=0;a[2]=0;a[3]=0;a[i]=1;for(j=0;j<4;j++){b[j]=G->edge[i][j];}t=max;for(k=0;k<4;k++){if(b[k]<t&&a[k]==0){t=b[k];p=k;}}a[p]=1;printf("%d到%d的最短路径为:%d\n",i,p,t); q=2;while(q>0){for(k=0;k<4;k++){if(a[k]==0)if(b[k]>(b[p]+G->edge[p][k]))b[k]=b[p]+G->edge[p][k];3}t=max;for(k=0;k<4;k++){if(b[k]<t&&a[k]==0){t=b[k];p=k;}}a[p]=1;--; qprintf("%d到%d的最短路径为:%d\n",i,p,b[p]); }t2=min;for(k=0;k<4;k++){if(t2<b[k]&&(k!=i)){t2=b[k];}c[i]=t2;}}//i的循环结束t=max;for(k=0;k<4;k++){if(t>c[k]){t=c[k];n=k;}}switch(n){case 0:printf("医院设在0村庄!");printf("0到最远村庄的最近距离为:%d\n",t); break;case 1:printf("医院设在1村庄!");printf("1到最远村庄的最近距离为:%d\n",t); break;case 2:4printf("医院设在2村庄!");printf("2到最远村庄的最近距离为:%d\n",t); break;case 3:printf("医院设在3村庄!");printf("3到最远村庄的最近距离为:%d\n",t);break;}}main(){Mgraph *G;G=(Mgraph*)malloc(sizeof(Mgraph));juzhen(G);panduan(G);}实验结果如下:五、实验总结这次实验和之前的实验相比有一定的难度，需要对实验的思路特别清晰，在其中设定的变量有些多，要特别注意，其中遇到了很多的问题，通过请教同学老师最终得出了结果～5。
数据结构图实验报告
数据结构图实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构图的基本概念、原理和操作方法，通过实际编程和操作，提高对数据结构的应用能力和解决问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容（一）线性表1、顺序表实现顺序表的创建、插入、删除、查找等基本操作。
分析顺序表在不同操作下的时间复杂度。
2、链表实现单链表、双向链表的创建、插入、删除、查找等基本操作。
比较单链表和双向链表在操作上的优缺点。
（二）栈和队列1、栈实现顺序栈和链式栈。
用栈解决表达式求值问题。
2、队列实现顺序队列和链式队列。
用队列模拟银行排队问题。
（三）树1、二叉树实现二叉树的创建、遍历（前序、中序、后序）。
计算二叉树的深度和节点数。
2、二叉搜索树实现二叉搜索树的插入、删除、查找操作。
分析二叉搜索树的性能。
（四）图1、图的存储实现邻接矩阵和邻接表两种图的存储方式。
比较两种存储方式的优缺点。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
用图的遍历解决最短路径问题。
四、实验步骤（一）线性表1、顺序表定义一个数组来存储顺序表的元素，并使用一个变量记录当前表的长度。
插入操作时，需要判断插入位置是否合法，如果合法则将插入位置后的元素依次向后移动一位，然后将新元素插入指定位置。
删除操作时，先判断删除位置是否合法，合法则将删除位置后的元素依次向前移动一位，并更新表的长度。
查找操作通过遍历数组来实现。
分析不同操作的时间复杂度，插入和删除操作在最坏情况下为O(n)，查找操作在平均情况下为 O(n/2)。
2、链表对于单链表，定义一个节点结构体，包含数据域和指向下一个节点的指针域。
通过操作指针来实现插入、删除和查找操作。
双向链表则在节点结构体中增加指向前一个节点的指针，使得操作更加灵活，但也增加了空间复杂度。
比较单链表和双向链表在插入、删除操作中指针的调整过程，得出双向链表在某些情况下更方便，但空间开销较大的结论。
数据结构实验六图
实验六图的表示与遍历一、实验目的1、掌握图的邻接矩阵和邻接表表示2、掌握图的深度优先和广度优先搜索方法3、理解图的应用方法二、实验内容和要求1、阅读并运行下面程序，根据输入写出运行结果。
#include<stdio.h>#define N 20#define TRUE 1#define FALSE 0int visited[N];typedef struct /*队列的定义*/{int data[N];int front,rear;}queue;typedef struct /*图的邻接矩阵*/{int vexnum,arcnum;char vexs[N];int arcs[N][N];}graph;void createGraph(graph *g); /*建立一个无向图的邻接矩阵*/ void dfs(int i,graph *g); /*从第i个顶点出发深度优先搜索*/ void tdfs(graph *g); /*深度优先搜索整个图*/void bfs(int k,graph *g); /*从第k个顶点广度优先搜索*/ void tbfs(graph *g); /*广度优先搜索整个图*/void init_visit(); /*初始化访问标识数组*/void createGraph(graph *g) /*建立一个无向图的邻接矩阵*/ { int i,j;char v;g->vexnum=0;g->arcnum=0;i=0;printf("输入顶点序列(以#结束)：\n");while((v=getchar())!='#'){g->vexs[i]=v; /*读入顶点信息*/i++;}g->vexnum=i; /*顶点数目*/for(i=0;i<g->vexnum;i++) /*邻接矩阵初始化*/for(j=0;j<g->vexnum;j++)g->arcs[i][j]=0;printf("输入边的信息：\n");scanf("%d,%d",&i,&j); /*读入边i,j*/while(i!=-1) /*读入i,j为－1时结束*/{g->arcs[i][j]=1;g->arcs[j][i]=1;scanf("%d,%d",&i,&j);}}void dfs(int i,graph *g) /*从第i个顶点出发深度优先搜索*/ {int j;printf("%c",g->vexs[i]);visited[i]=TRUE;for(j=0;j<g->vexnum;j++)if((g->arcs[i][j]==1)&&(!visited[j]))dfs(j,g);}void tdfs(graph *g) /*深度优先搜索整个图*/{int i;printf("\n从顶点%C开始深度优先搜索序列：",g->vexs[0]); for(i=0;i<g->vexnum;i++)if(visited[i]!=TRUE)dfs(i,g);}void bfs(int k,graph *g) /*从第k个顶点广度优先搜索*/{int i,j;queue qlist,*q;q=&qlist;q->rear=0;q->front=0;printf("%c",g->vexs[k]);visited[k]=TRUE;q->data[q->rear]=k;q->rear=(q->rear+1)%N;while(q->rear!=q->front){i=q->data[q->front];q->front=(q->front+1)%N;for(j=0;j<g->vexnum;j++)if((g->arcs[i][j]==1)&&(!visited[j])){printf("%c",g->vexs[j]);visited[j]=TRUE;q->data[q->rear]=j;q->rear=(q->rear+1)%N;}}}void tbfs(graph *g) /*广度优先搜索整个图*/{int i;printf("\n从顶点%C开始广度优先搜索序列：",g->vexs[0]); for(i=0;i<g->vexnum;i++)if(visited[i]!=TRUE)bfs(i,g);}void init_visit() /*初始化访问标识数组*/{int i;for(i=0;i<N;i++)visited[i]=FALSE;}int main(){graph ga;int i,j;createGraph(&ga);printf("无向图的邻接矩阵：\n");for(i=0;i<ga.vexnum;i++){for(j=0;j<ga.vexnum;j++)printf("%3d",ga.arcs[i][j]);printf("\n");}init_visit();tdfs(&ga);init_visit();tbfs(&ga);return 0;}▪ 根据右图的结构验证实验，输入：ABCDEFGH#0,1 0,20,5 1,31,4 2,52,63,74,7-1,-1▪ 运行结果：2、阅读并运行下面程序，补充拓扑排序算法。
实验五 图的遍历
实验五图的基本操作一、实验目的与内容1.实验目的1、使学生可以巩固所学的有关图的基本知识。
2、熟练掌握图的存储结构。
3、熟练掌握图的两种遍历算法。
2.实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。
[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
[测试数据]由学生依据软件工程的测试技术自己确定。
二．程序设计1.总体设计#include<iostream.h>#define MaxVerNum 20struct Edgenode{int edgever; //该弧所指向的的顶点的信息int inform; //该边的信息Edgenode *edgenext; //指向下一条边的指针};struct Vexnode{char vertex;Edgenode *firstarc;};struct Graph{Vexnode AdjList[MaxVerNum];int vexnum,arcnum ;//图的当前顶点数和弧数};//队列的定义及相关函数的实现struct QueueNode{int nData;QueueNode* next;};struct QueueNode{QueueNode* front;QueueNode* rear;};void EnQueue(QueueList* Q,int e); //进队操作void DeQueue(QueueList* Q,int* e); //出队操作void CreatAdjList(Graph* G); //创建图void DFS(Graph *G,int i,int visit[]); //从第i个顶点出发递归的深度优先遍历图Gvoid DFStraversal(Graph *G,char c); //对图G作深度优先遍历void BFS(Graph* G,int v,int visit[]); //从第v个顶点出发递归的广度优先遍历图Gvoid BFStraversal(Graph *G,char c); //对图G作广度优先遍历2.详细设计●定义结构体QueueNode、QueueNode，并完成队列的基本操作，利用队列先进先出的性质，在广度优先遍历时将队列作为辅助工具来完成广度优先遍历。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告
实验五
实验题目：图子系统
指导老师：王春红
专业班级：计算机科学与技术系1105班
姓名：李慧2011100521杜丽20111005122
白莹2011100523王媛2011100529
2013年 5月23日
实验类型综合实验室_软件实验室一__
一、实验题目
图子系统
二、实验目的和要求
１．掌握图的存储思想及其存储实现
２．掌握图的深度、广度优先遍历算法思想及其程序实现
３．掌握图的常见应用算法的思想及其程序实现。
三、实验内容
实验内容二：所有顶点对的最短路径
1．设置4个村庄之间的交通，村庄之间的距离用各边上的权值来表示。
现在要求从这4个村庄中选择一个村庄建一所医院，问这所医院应建在哪个村庄，才能使离医院最远的村庄到医院最近。
2．设计分析
用有向加权图表示的交通图中，有向边<vi,vj>表示第i个村庄和第j个村庄之间有道路，边上的权表示这条道路的长度。
该问题的实质是求解任意两顶点间的最短路径问题。
即求出每个顶点到其他顶点的最短路径的最大值，最大值最小的顶点作为医院所在村庄。
3．结构类型定义
typedef char vextype;/*顶点数据类型*/
typedef int edgetype;/*边数据类型*/
typedef struct
{
vextype vex[maxsize];
edgetype arc[maxsize][maxsize];
int vexnum,arcnum;
}Mgraph;
小组分工：
组长：王媛定义结构体和主函数
组员：李慧void juzhen(Mgraph *G)
白莹、杜丽void panduan(Mgraph *G)
四、实验步骤
程序如下：
#include <stdio.h>
#include <malloc.h>
#define max 100
#define min 0
typedef int edgetype;
typedef char vextype;
typedef struct
{
vextype ver[4];
edgetype edge[4][4];
int edgenum,vernum;
}Mgraph;
void juzhen(Mgraph *G)
{
int i,j;
printf("四个村庄的邻接矩阵为:\n");
for(i=0;i<4;i++)
for(j=0;j<4;j++)
scanf("%d",&G->edge[i][j]);
}
void panduan(Mgraph *G)
{
int a[4],b[4],c[4];
int i,j,t,t2,p,q,n,k;
for(i=0;i<4;i++)
{
a[0]=0;a[1]=0;a[2]=0;a[3]=0;
a[i]=1;
for(j=0;j<4;j++)
{
b[j]=G->edge[i][j];
}
t=max;
for(k=0;k<4;k++)
{
if(b[k]<t&&a[k]==0)
{
t=b[k];
p=k;
}
}
a[p]=1;
printf("%d到%d的最短路径为：%d\n",i,p,t); q=2;
while(q>0)
{
for(k=0;k<4;k++)
{
if(a[k]==0)
if(b[k]>(b[p]+G->edge[p][k]))
b[k]=b[p]+G->edge[p][k];
}
t=max;
for(k=0;k<4;k++)
{
if(b[k]<t&&a[k]==0)
{
t=b[k];
p=k;
}
}
a[p]=1;
q--;
printf("%d到%d的最短路径为：%d\n",i,p,b[p]); }
t2=min;
for(k=0;k<4;k++)
{
if(t2<b[k]&&(k!=i))
{
t2=b[k];
}
c[i]=t2;
}
}//i的循环结束
t=max;
for(k=0;k<4;k++)
{
if(t>c[k])
{
t=c[k];
n=k;
}
}
switch(n)
{
case 0:
printf("医院设在0村庄!");
printf("0到最远村庄的最近距离为:%d\n",t);
break;
case 1:
printf("医院设在1村庄!");
printf("1到最远村庄的最近距离为:%d\n",t);
break;
case 2:
printf("医院设在2村庄!");
printf("2到最远村庄的最近距离为:%d\n",t);
break;
case 3:
printf("医院设在3村庄!");
printf("3到最远村庄的最近距离为:%d\n",t);
break;
}
}
main()
{
Mgraph *G;
G=(Mgraph*)malloc(sizeof(Mgraph));
juzhen(G);
panduan(G);
}
实验结果如下：
五、实验总结
这次实验和之前的实验相比有一定的难度，需要对实验的思路特别清晰，在其中设定的变量有些多，要特别注意，其中遇到了很多的问题，通过请教同学老师最终得出了结果！。