数据结构实习报告_图

合集下载

数据结构实验———图实验报告

数据结构实验报告目的要求１．掌握图的存储思想及其存储实现..２．掌握图的深度、广度优先遍历算法思想及其程序实现..３．掌握图的常见应用算法的思想及其程序实现..实验内容１．键盘输入数据;建立一个有向图的邻接表..２．输出该邻接表..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实验总结这次的图的操作实验;与树的操作类似;但又比树复杂;包含更多的存储结构和遍历方法的操作;而且图的遍历需要沿着弧进行;以便输出弧上的信息..本实验中图的遍历采用邻接表的存储结构;在输入图的信息时;首先要画出图的邻接表信息..图有两种遍历的形式;一种为深度优先搜索;另一种为广度优先搜索..由于能力有限;没能实现图的深度非递归优先搜索;而是实现了图的深度递归优先搜索..本实验基本完成了图的操作;也学到了很多关于图的知识和算法..。

《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。

2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。

二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。

2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范，及时完成实验报告。

四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。

数据结构实习报告

数据结构实习报告
实习报告：数据结构实习
实习时间：20xx年xx月xx日-20xx年xx月xx日
实习单位：xxx公司
实习内容：
1. 数据结构基础学习：在实习中，我首先对数据结构进行了系统的学习。

通过阅读相关书籍和参与公司内部培训，我对常用的数据结构如链表、栈、队列、树等有了更深入的了解，并了解了它们的特点、用途以及操作方法。

2. 数据结构算法实践：在实习中，我有机会参与公司的项目开发工作，从中学习和应用了各种数据结构算法。

例如，在一个项目中，我利用栈的特点，实现了一个基于深度优先搜索的路径查找算法。

这个算法在处理大规模数据时表现出了良好的性能。

3. 数据结构优化：在项目中，我发现某些数据结构的性能不够理想，导致程序运行速度较慢。

于是我对这些数据结构进行了分析，并提出了相应的优化方案。

通过使用更加高效的数据结构，我成功地提升了程序的性能。

4. 数据结构的应用：在实习中，我也有机会应用数据结构解决实际问题。

例如，在一个项目中，我使用了二叉查找树来实现一个关键词搜索功能，通过对数据进行合理的排列，提高了搜索的效率。

实习总结：
通过这次实习，我不仅对数据结构有了更深入和系统的了解，还学到了如何将数据结构应用到实际的项目开发中。

在实践中，我不断地提升了自己的编码能力和问题解决能力。

同时，与团队成员的合作也让我更好地理解了团队协作的重要性。

通过实习，我对数据结构的实际应用有了更深刻的认识，并且对软件开发工作有了更全面的了解。

我相信这次实习对我的专业能力和职业发展都会产生积极的影响。

数据结构试验报告-图的基本操作

中原工学院《数据结构》实验报告学院：计算机学院专业：计算机科学与技术班级：计科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、实验目的
本实验主要旨在通过实践操作，深入理解图这种数据结构的基本概念、性质和基本操作，掌握图的存储结构与常见算法。

2、实验环境
本次实验使用编程语言C++，在Windows平台下进行开发和运行。

3、实验内容
3.1 图的定义与基本概念
在本章中，我们将介绍图的基本概念，包括有向图与无向图、顶点与边、度与入度出度、连通性等。

3.2 图的存储结构
在本章中，我们将介绍图的几种存储结构，包括邻接矩阵、邻接表和十字链表，以及它们的优缺点和适用场景。

3.3 图的遍历
在本章中，我们将介绍图的两种常用的遍历算法，即深度优先搜索（DFS）和广度优先搜索（BFS），并分别给出它们的实现代码和应用场景。

3.4 最短路径
在本章中，我们将介绍图的最短路径问题，包括单源最短路径和全源最短路径。

我们将使用Dijkstra算法和Floyd-Warshall算法来解决这些问题，并给出它们的实现代码和应用场景。

3.5 最小树
在本章中，我们将介绍图的最小树问题，即找到一棵树使得树上的边的权值之和最小。

我们将使用Prim算法和Kruskal算法来解决这个问题，并给出它们的实现代码和应用场景。

4、实验步骤和结果
在本章中，我们将详细介绍实验的具体步骤，并给出实验结果的详细分析和说明。

5、实验总结
在本章中，我们将对整个实验进行总结，总结实验中遇到的问题、解决方案和经验教训。

6、附件
本实验报告所涉及的附件包括实验代码和运行结果的截图。

7、法律名词及注释
本文所涉及的法律名词和注释详见附件中的相关文件。

数据结构实验报告—图

《算法与数据结构》课程实验报告一、实验目的1.实现图的存储结构;2.通过图的相关算法实现，掌握其算法思想。

二、实验内容及要求1.无向带权图的存储结构(邻接矩阵、邻接表等自选)2.实现图的相关算法(1)计算指定顶点的度(2)图的深度优先遍历和广度优先遍历算法(3)分别使用Kruskal和Prim算法求解该图的最小生成树三、系统分析（1）数据方面：定义图的模板基类，在模板类定义中的数据类型参数表<class T,class E>中，T是定点数据的类型，E是边上所附数据的类型。

这个模板基类是按照带权无向图来定义的。

在该实验中定点的数据的类型为char型，边上所附数据的类型为int型。

且图的创建为无向图。

（2）功能方面：1.能够实现图的创建以及图的输出。

2.能够返回顶点在图中位置以及图中位置对应顶点的值。

3.返回当前图中的边数与顶点数。

4.返回输入边的权值。

5.能够插入一个顶点或插入顶点与之相关联的边。

6.删除边或删除顶点与之相关联的边。

7.计算顶点的度。

8.实现深度优先搜索、广度优先搜索遍历。

9.Kruskal算法、Prim算法生成最小生成树。

四、系统设计（1）设计的主要思路根据实验要求，首先确定图的存储结构，在根据存储结构编写模板类，并将需要实现的功能代码完善，再写出实现各个功能的菜单并进行调试。

由于在编写由图生成最小生成树中采用了最小堆以及并查集的算法，故需要将这两个个类的代码完成并进行调试。

最后将此次实验所涉及的类全部整理完全后，通过之前编写的菜单对功能进行依次调试，完成此次实验。

（2）数据结构的设计图是非线性结构，它的每一个顶点可以与多个其他顶点相关联，各顶点之间的关系是任意的。

可以用很多方法来存储图结构。

在此采用邻接矩阵来存储图结构。

首先将所有顶点的信息组织成一个顶点表，然后利用一个矩阵来表示各顶点之间的邻接关系，称为邻接矩阵。

下面针对带权无向图的邻接矩阵作出说明。

其中有一个类型为顺序表的顶点表向量VerticesList，用以存储顶点的信息，还有一个作为邻接矩阵使用的二维数组Edge，用以存储图中的边，其矩阵元素个数取决于顶点个数，与边数无关。

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

操作系统为 Windows 10。

三、实验内容1、链表的实现与操作创建一个单向链表，并实现插入、删除和遍历节点的功能。

对链表进行排序，如冒泡排序或插入排序。

2、栈和队列的应用用栈实现表达式求值，能够处理加、减、乘、除和括号。

利用队列实现银行排队系统的模拟，包括顾客的到达、服务和离开。

3、二叉树的遍历与操作构建一棵二叉树，并实现前序、中序和后序遍历。

进行二叉树的插入、删除节点操作。

4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。

实现图的深度优先遍历和广度优先遍历。

四、实验步骤及结果1、链表的实现与操作首先，定义了链表节点的结构体：｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀插入节点的函数：｀｀｀cppvoid insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；head ＝ newNode;｝ else ｛ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝｝｀｀｀删除节点的函数：｀｀｀cppvoid deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝｀｀｀遍历链表的函数：｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛std:：cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝std:：cout ＜＜ std:：endl;｝｀｀｀对链表进行冒泡排序的函数：｀｀｀cppvoid bubbleSortList(ListNode& head) ｛if （head ＝＝ NULL ｜｜ head>next ＝＝ NULL) ｛return;｝bool swapped;ListNode ptr1;ListNode lptr ＝ NULL;do ｛swapped ＝ false;ptr1 ＝ head;while （ptr1-＞next!＝ lptr) ｛if （ptr1-＞data ＞ ptr1-＞next>data) ｛int temp ＝ ptr1-＞data;ptr1-＞data ＝ ptr1-＞next>data;ptr1-＞next>data ＝ temp;swapped ＝ true;｝ptr1 ＝ ptr1-＞next;｝lptr ＝ ptr1;｝ while （swapped)；｝｀｀｀测试结果：创建了一个包含 5、3、8、1、4 的链表，经过排序后，输出为 1 3 4 5 8 。

数据结构实验报告图

数据结构实验报告图数据结构实验报告图问题描述：;四则运算表达式求值，将四则运算表达式用中缀表达式;一、需求分析：;1、本程序是利用二叉树后序遍历来实现表达式的转换;2、输入输出格式：;输入格式：在字符界面上输入一个中缀表达式，回车表;请输入表达式：;输入一个中缀表达式;输出格式：如果该中缀表达式正确，那么在字符界面上;式，其中后缀表达式中两相邻操作数之间利用空格隔开;果不正确，在字符界面上输出问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。

一、需求分析：1、本程序是利用二叉树后序遍历来实现表达式的转换，同时可以使用实验三的结果来求解后缀表达式的值。

2、输入输出格式：输入格式：在字符界面上输入一个中缀表达式，回车表示结束。

请输入表达式：输入一个中缀表达式输出格式：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开;如果不正确，在字符界面上输出表达式错误提示。

逆波兰表达式为：3、测试用例输入：21+23*(12-6)输出：21 23 12 6 -*+ 输出逆波兰表达式运算结果为：输出运算后的结果二、概要设计：抽象数据类型二叉树类BiTree算法的基本思想根据题目要求，利用栈计算，和二叉树存储，来计算表达式该算法的基本思想是：先利用栈进行计算，然后用二叉树进行存储，和实验三算法一样来计算逆波兰表达式的值程序的流程程序由三个模块组成：(1) 输入模块：输入一个运算式(2) 计算模块：利用栈进行表达式的计算，二叉树来存储。

(3 ) 输出模块：屏幕上显示出后缀表达式和运算结果。

三、详细设计物理数据类型程序含有两个类，其中栈不再赘述，另一个类为二叉树class BiTree包含私有成员struct BiTreeNode，根节点BiTreeNode *T;索引index; int number_of_point 优先级比较函数compare(char a,char b);生成树的函数void InorderCreate(BiTreeNode *&T,char str,int start,int end);判断数字函数bool IsNumber(char a);求值函数double Operate(BiTreeNode *T);还有显示后缀表达式的函数void display(BiTreeNode *T) ;而公有成员函数则是对私有函数的重载，为方便使用，因为函数中普遍使用了递归的算法。

数据结构图实验报告

1. 了解熟知图的定义和图的基本术语，掌握图的几种存储结构。

2. 掌握邻接矩阵和邻接表定义及特点，并通过实例解析掌握邻接矩阵和邻接表的类型定义。

3. 掌握图的遍历的定义、复杂性分析及应用，并掌握图的遍历方法及其基本思想。

1. 建立无向图的邻接矩阵2. 图的深度优先搜索3. 图的广度优先搜索建立无向图的邻接矩阵：源代码：#include "stdio.h"#include "stdlib.h"#define MAXSIZE 30typedef structchar vertex[MAXSIZE];//顶点为字符型且顶点表的长度小于MAXSIZEint edges[MAXSIZE][MAXSIZE];//边为整形且 edges 为邻近矩阵}MGraph;//MGraph 为采用邻近矩阵存储的图类型void CreatMGraph(MGraph *g,int e,int n){//建立无向图的邻近矩阵 g- >egdes，n 为顶点个数， e 为边数int i,j,k;printf("Input data of vertexs(0~n-1):\n");for(i=0;i<n;i++)g- >vertex[i]=i; //读入顶点信息for(i=0;i<n;i++)for(j=0;j<n;j++)g- >edges[i][j]=0; //初始化邻接矩阵for(k=1;k<=e;k++)//输入 e 条边{printf("Input edges of(i,j):");scanf("%d,%d",&i,&j);g- >edges[i][j]=1;g- >edges[j][i]=1;}void main(){int i,j,n,e;MGraph *g; //建立指向采用邻接矩阵存储图类型指针g=(MGraph*)malloc(sizeof(MGraph));//生成采用邻接举证存储图类型的存储空间printf("Input size of MGraph:"); //输入邻接矩阵的大小scanf("%d",&n);printf("Input number of edge:"); //输入邻接矩阵的边数scanf("%d",&e);CreatMGraph(g,e,n); //生成存储图的邻接矩阵printf("Output MGraph:\n");//输出存储图的邻接矩阵for(i=0;i<n;i++){for(j=0;j<n;j++)printf("%4d",g- >edges[i][j]);printf("\n");}}1) 源代码：#include "stdio.h"#include "stdlib.h"#define MAXSIZE 30typedef struct node//邻接表结点{int adjvex;//邻接点域struct node *next;//指向下一个邻接边结点的指针域}EdgeNode; //邻接表结点类型typedef struct vnode//顶点表结点{int vertex;//顶点域EdgeNode *firstedge; // 指向邻接表第一个邻接边节点的指针域}VertexNode;//顶点表结点类型void CreatAdjlist(VertexNode g[],int e,int n){//建立无向图的邻接表， n 为顶点数， e 为边数， g[]存储 n 个顶点表结点EdgeNode *p;int i,j,k;printf("Input data of vetex(0~n-1);\n");for(i=0;i<n;i++)//建立有 n 个顶点的顶点表{g[i].vertex=i; //读入顶点 i 信息g[i].firstedge=NULL; //初始化指向顶点 i 的邻接表表头指针}for (k=1;k<=e;k++)//输入 e 条边{printf("Input edge of(i,j):");scanf("%d,%d",&i,&j);p=(EdgeNode*)malloc(sizeof(EdgeNode));p- >adjvex=j; //在顶点 vi 的邻接表中添加邻接点为j 的结点p- >next=g[i].firstedge; //插入是在邻接表表头进行的g[i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));p- >adjvex=i; //在顶点 vj 的邻接表中添加邻接点为 i 的结点p- >next=g[j].firstedge; //插入是在邻接表表头进行的g[j].firstedge=p;}}int visited[MAXSIZE]; //MAXSIZE 为大于或者等于无向图顶点个数的常量void DFS(VertexNode g[],int i){EdgeNode *p;printf("%4d",g[i].vertex); //输出顶点 i 信息，即访问顶点 i visited[i]=1;p=g[i].firstedge; //根据顶点 i 的指针 firstedge 查找其邻接表的第一个邻接边结点while(p!=NULL){if(!visited[p- >adjvex]) //如果邻接的这个边结点未被访问过DFS(g,p- >adjvex); //对这个边结点进行深度优先搜索p=p- >next; //查找顶点 i 的下一个邻接边结点}}void DFSTraverse(VertexNode g[],int n){//深度优先搜索遍历以邻接表存储的图，其中 g 为顶点数， n 为顶点个数int i;for(i=0;i<n;i++)visited[i]=0; //访问标志置 0for(i=0;i<n;i++)//对 n 个顶点的图查找未访问过的顶点并由该顶点开始遍历if(!visited[i]) //当 visited[i]等于 0 时即顶点 i 未访问过DFS(g,i); //从未访问过的顶点 i 开始遍历}void main(){int e,n;VertexNode g[MAXSIZE]; //定义顶点表结点类型数组 gprintf("Input number of node:\n");//输入图中节点个数边的个数scanf("%d",&n);printf("Input number of edge:\n");//输入图中边的个数scanf("%d",&e);printf("Make adjlist:\n");CreatAdjlist(g,e,n); //建立无向图的邻接表printf("DFSTraverse:\n");DFSTraverse(g,n); //深度优先遍历以邻接表存储的无向图printf("\n");}1) 源代码：#include "stdio.h"#include "stdlib.h"#define MAXSIZE 30typedef struct node1//邻接表结点{int adjvex; //邻接点域struct node1 *next;//指向下一个邻接边结点的指针域}EdgeNode; //邻接表结点类型typedef struct vnode//顶点表结点{int vertex;//顶点域EdgeNode *firstedge; // 指向邻接表第一个邻接边结点的指针域}VertexNode; //顶点表结点类型void CreatAdjlist(VertexNode g[],int e,int n){ //建立无向图的邻接表，n 为顶点数，e 为边数，g[]存储 n 个顶点表结点EdgeNode *p;int i,j,k;printf("Input data of vetex(0~n-1):\n");for(i=0;i<n;i++) //建立有 n 个顶点的顶点表{g[i].vertex=i; //读入顶点 i 信息g[i].firstedge=NULL; //初始化指向顶点 i 的邻接表表头指针}for(k=1;k<=e;k++) //输入 e 条边{printf("Input edge of(i,j):");scanf("%d,%d",&i,&j);p=(EdgeNode *)malloc(sizeof(EdgeNode));p- >adjvex=j;//在定点 vi 的邻接表中添加邻接点为 j 的结点p- >next=g[i].firstedge;//插入是在邻接表表头进行的g[i].firstedge=p;p=(EdgeNode *)malloc(sizeof(EdgeNode));p- >adjvex=i; //在顶点 vj 的邻接表中添加邻接点为 i 的结点p- >next=g[j].firstedge; //插入是在邻接表表头进行的g[j].firstedge=p;}}typedef struct node{int data;struct node *next;}QNode; //链队列结点的类型typedef struct{QNode *front,*rear; //将头、尾指针纳入到一个结构体的链队列}LQueue; //链队列类型void Init_LQueue(LQueue **q) //创建一个带头结点的空队列{QNode *p;*q=(LQueue *)malloc(sizeof(LQueue)); //申请带头、尾指针的链队列p=(QNode *)malloc(sizeof(QNode)); //申请链队列的头结点p- >next=NULL;//头结点的 next 指针置为空(*q)- >front=p; //队头指针指向头结点(*q)- >rear=p; //队尾指针指向头结点}int Empty_LQueue(LQueue *q) //判队空{if(q- >front==q- >rear) //队为空return 1;elsereturn 0;}void In_LQueue(LQueue *q,int x) //入队{QNode *p;p=(QNode *)malloc(sizeof(QNode)); //申请新链队列结点p- >data=x;p- >next=NULL; //新结点作为队尾结点时其 next 域为空q- >rear- >next=p; //将新结点*p 链到原队尾结点之后q- >rear=p; //使队尾指针指向新的队尾结点*p}void Out_LQueue(LQueue *q,int *x) //出队{QNode *p;if(Empty_LQueue(q))printf("Queue is empty!\n");//对空，出队失败else{p=q- >front- >next; //指针 p 指向链队列第一个数据结点(即对头结点)q- >front- >next=p- >next;//头结点的 next 指针指向链队列第二个数据结点(即删除第一个数据结点)*x=p- >data; //将删除的对头结点数据经由 x 返回free(p);if(q- >front- >next==NULL) //出队后队为空，则置为空q- >rear=q- >front;}}int visited[MAXSIZE]; //MAXSIZE 为大于或者等于无向图顶点个数的常量void BFS(VertexNode g[],LQueue *Q,int i){//广度优先搜索遍历邻接表存储的图，g 为顶点表，Q 为队指针，i 为第 i 个顶点int j,*x=&j;EdgeNode *p;printf("%4d",g[i].vertex); //输出顶点 i 信息，即访问顶点 i visited[i]=1; //置顶点 i 为访问过标志In_LQueue(Q,i); //顶点 i 入队 Qwhile(!Empty_LQueue(Q)) //当队 Q 非空时{Out_LQueue(Q,x); //对头顶点出队并送 j (暂记为顶点 j )p=g[j].firstedge;// 根据顶点 j 的表头指针查找其邻接表的第一个邻接边结点while(p!=NULL){if(!visited[p- >adjvex])//如果邻接的这个边结点未被{printf("%4d",g[p- >adjvex].vertex); // 输出这个邻接边结点的顶点信息visited[p- >adjvex]=1; //置该邻接边结点为访问过标志In_LQueue(Q,p- >adjvex); //将该邻接边结点送人队 Q}p=p- >next;//在顶点j 的邻接表中查找j 的下一个邻接边结点}}}void main(){int e,n;VertexNode g[MAXSIZE];//定义顶点表结点类型数组 gLQueue *q;printf("Input number of node:\n"); //输入图中结点个数scanf("%d",&n);printf("Input number of edge:\n");//输入图中边的个数scanf("%d",&e);printf("Make adjlist:\n ");CreatAdjlist(g,e,n);//建立无向图的邻接表Init_LQueue(&q);//队列 q 初始化printf("BFSTraverse:\n");BFS(g,q,0); //广度优先遍历以邻接表存储的无向图printf("\n");}1．通过本次试验让我对图的遍历以及图的深度和广度优先搜索有了更深刻的记忆和理解，将课本理论的知识得以实践。

大一数据结构集中上机实习报告

exp3=exp1->next;
exp1->next=exp2->next;
exp2->next=exp3;
exp3=exp1->pre;
exp1->pre=exp2->pre;
exp2->pre=exp3;
}
exp3=exp1;
exp1=exp2;
exp2=exp3;
break;
}
}
exp2=exp2->next;
printf("查找失败!\n");
return const_Fail;
}
else{
*res=b;
temp=b->name;
printf("姓名:");
for(counter2=0;counter2<=limit;counter2++){
putchar(*temp);
temp++;
}
printf("\n");
}
}//插入新元素
int link_search(headpoint &a,experiment **res)
{
experiment *b;
b=a.head;
char info[21],*temp;
int counter2,limit=0,result;
if(a.length==0){
printf("空!\n");//判断通讯录是否为空
}while(*tempor!='\0');
printf("\n");
tempor=temp->phonenumber;

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

数据结构课程设计实习报告题目：图的基本操作学号：1210522姓名：何厚华年级：大二学院：计算机与控制工程学院专业：计算机科学与技术完成日期：2014年5月21日授课教师：辛运帏目录1.题目 (2)2.要求... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... . (2)3.程序实现... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... (3)3.1程序运行及编译环境 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... (3)3.2程序描述 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... (3)3.3实现功能... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... . (3)3.3.1子功能模块 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... (4)3.3.1.1 子功能模块1 ... ... ... ... ... ... ... ... ... ... ... ... ... ... (4)3.3.1.2子功能模块2... ... ... ... ... ... ... ... ... ... ... ... ... ... . (5)3.3.1.3子功能模块3... ... ... ... ... ... ... ... ... ... ... ... ... ... . (5)3.3.1.4子功能模块4... ... ... ... ... ... ... ... ... ... ... ... ... . (5)3.3.1.5子功能模块5.. ... ... .... ... ... ... ... ... ... ... ... ... ... (5)3.3.2 数据结构... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... . (6)3.3.2.1 数据结构的操作1 .. ... ... ... ... ... ... ... ... ... ... ... (7)3.3.2.2 数据结构的操作2 .. ... ... ... ... ... ... ... ... ... ... ... (7)3.3.2.3 数据结构的操作3 .... ... ... ... ... ... ... ... ... ... .. 83.3.3算法及程序说明... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... (13)3.4运行结果 .. ... ... ... ... ... ... ... ... ... ... ... ... ... ... .... .... .... (14)3.5尚未解决的问题 .... ... ... ... ... ... ... ... ... ... ... ... ... ... .... .... .... (16)1.题目图的基本操作给定N个顶点、E条边的图G，完成图的相关算法，具体要求如下：1 完成图的创建方法，即从键盘或文件输入图的信息，建立图的邻接表或是邻接矩阵存储结构。

2 给出判定图的性质的算法，即能够判定图是否是有向图、无向图、有向无环图、连通图、哈密尔顿图等。

3 根据输入的图的性质，实现以下算法（选择其中一两个）：如果图是有向无环图，则先实现图的某种遍历算法，在此基础上实现图的拓扑排序算法。

如果图是连通图，则求出图的最大．生成树（不是最小生成树，参考讲授的方法），即得到的生成树权值之和最大。

如果图是无向图，则以第一个顶点当做源点，求出单源最短路径。

对于哈密尔顿图，找出其哈密尔顿回路。

2.要求：初始输入数据的格式由自己定义，例如，输入文件中保存的初始数据格式有以下两种：格式一3∞ 3 2∞∞ 15 ∞∞解释：第一行是图中所含顶点个数m，后面是m行m列数据，对应邻接矩阵。

格式二3 41 2 31 3 22 3 13 1 5解释：第一行是图中所含顶点个数m和边数e，后面是e条边的信息，如1 2 3表示顶点1到顶点2有权值为3的边。

3.程序实现3.1程序运行及编译环境程序是用Visual Studio 2010即VS10.0 编译的。

可以在windows系列的操作系统上运行。

3.2程序描述该程序主要用于实现图的基本操作,包括：建立邻接矩阵存储结构，给出判定图的性质的算法，即能够判定图是否是有向图、无向图、有向无环图、连通图、哈密尔顿图等，然后在此基础上，如果图是连通图，则求出图的最大．生成树，如果图是无向图，则以第一个顶点当做源点，求出单源最短路径。

其流程如下：A).程序读取输入文件，并生成相应的数据结构a.用二维数组来声明并存储图，完成初始化的工作b.建立图的邻接矩阵存储c.生成图的一步可达矩阵B).输出相关信息a.判断图是否是有向图b.判断图是否是无向图c.判断图是否是连通图d.判断图是否是有向无环图e.判断图是否是哈密顿图C).编码以及译码a.如果图是连通图，则求出图的最大．生成树。

b.如果图是无向图，则以第一个顶点当做源点，求出单源最短路径。

D).完成3.3实现功能建立邻接矩阵存储结构，给出判定图的性质的算法，即能够判定图是否是有向图、无向图、有向无环图、连通图、哈密尔顿图等，然后在此基础上，如果图是连通图，则求出图的最大．生成树，如果图是无向图，则以第一个顶点当做源点，求出单源最短路径。

3.3.1 子功能模块子功能按照是否对象的方法分类：数组的处理以及树的处理；3.3.1.1子功能模块1/******************函数原型：int Pow(int x,int base=10);*****************************函数参数：x 表示指数***********************************************函数功能：求base的幂次**************************/int Pow(int x,int base=10){if(x==0) return 1;return base*Pow(x-1);}3.3.1.2子功能模块2/***************函数原型：float Convert2Num(char* str)*****************************函数参数：str 是文件流中的字符串***********************************函数功能：把一个数字字符串转化为一个数字************/ float Convert2Num(char* str){float num=0;int i=0,dot=0;if((*str)=='I')return INF;while(*(str+i)){if(dot!=0) dot++;if(*(str+i)!='.')num=10*num+*(str+i)-'0';elsedot=1;i++;}return dot==0?num:num/Pow(dot-1);}3.3.1.3子功能模块3函数功能：Mul矩阵平方放到result矩阵中V oid SquareMatrix (int Mul[MAXNODES][MAXNODES],intresult[MAXNODES][MAXNODES],int n){for(int k=0;k<n;k++){for(int l=0;l<n;l++){result[k][l]=0;for(int m=0;m<n;m++)if(Mul[k][m]*Mul[m][l]!=0){result[k][l]=1;break;}}}}3.3.2 数据结构/******************************************************************** 图这个数据结构的定义，从文件读入，用邻接矩阵存储NodesCount表示结点个数，AdjMatrix[MAXNODES][MAXNODES]是邻接矩阵Connect[MAXNODES][MAXNODES]表示一步可达矩阵，其中点到自身为可达*********************************************************************/ class Graph{int NodesCount;float AdjMatrix[MAXNODES][MAXNODES];int Connect[MAXNODES][MAXNODES];public:Graph(ifstream &fin);//从文件读入图的元素，建立邻接矩阵bool IsUnDirectedGraph();//判断是否是无向图bool IsDirectedGraph();// 判断是否是有向图bool IsDirectWithoutLoop();//判断是否是有向无环图bool IsConnected();//判断是否是连通图void Prim(int v);//从节点v开始，用类似prim算法的方法生成最大生成树void floyd();//用floyd算法求任意两个点之间的最短距离int GetNodesCount();//};3.3.2.1 数据结构的操作1/************************************************************************************函数原型：Graph::Graph(ifstream &fin)*****************************函数参数：fin 存放图的文件*******************************************函数功能：构造函数，把一个图从文件读入******************************************************************************/ Graph::Graph(ifstream &fin){char a[ MAXLENGTH];................................NodesCount=0;while(!fin.eof()){i=0;while(fin.get(ch)){..................}if(!NodesCount)//NodesCount有数即不再读入NodesCount=Convert2Num(a);else{num=Convert2Num(a);AdjMatrix[idx/NodesCount][idx%NodesCount]=num;//邻接矩阵Connect[idx/NodesCount][idx%NodesCount]=(num==INF&&(idx/NodesCount!=idx%NodesCount)?0:1);//一步可达矩阵idx++;}}}3.3.2.2 数据结构的操作2/************************************************************************************函数原型：bool Graph::IsUnDirectedGraph()*****************************函数参数：判断图是否是无向图*******************************************实现方法：判断邻接矩阵是否是对称的，如对称，则无向**********************************************************************/bool Graph::IsUnDirectedGraph(){for(int k=0;k< NodesCount-1;k++){for(int l=k+1;l<NodesCount;l++){if(AdjMatrix[k][l]!=AdjMatrix[l][k])return false;}}return true;}3.3.2.3 数据结构的操作3/************************************************************************************函数原型：bool Graph::IsConnected()**********************************实现方法：将一步可达矩阵依次平方，直到该乘积收敛得到的*************** 就是这个图的可达矩阵，这个算法复杂度是o(n^2lgn)由于一步可达矩阵的对角线的元素全为1，而且矩阵的乘法是逻辑乘，所以，这个矩阵原来的某个位置如果为1，那么一直为1，最后一定会收敛，这里是将这个矩阵平方后再平方，加快收敛速度，从而快速判断这个图是否是连通的******************************************************************/bool Graph::IsConnected(){int temp1[MAXNODES][MAXNODES];int temp2[MAXNODES][MAXNODES];int temp;for(int k=0;k< NodesCount;k++)for(int l=0;l<NodesCount;l++)temp1[k][l]=Connect[k][l];//初始化temp1矩阵do{SquareMatrix(&temp1[0],&temp2[0],NodesCount);//temp2=temp1^2for(int k=0;k< NodesCount;k++)for(int l=0;l<NodesCount;l++){temp=temp1[k][l];temp1[k][l]=temp2[k][l];temp2[k][l]=temp;}}while(!IsSameMatrix(&temp1[0],&temp2[0],NodesCount));//直到收敛，也即temp2=temp2^2cout<<"可达矩阵如下："<<endl;printMatrix(&temp2[0],NodesCount);if(IsFull(&temp2[0],NodesCount))//任两点可达，图是连通的return true;return false;}3.3.2.4 数据结构的操作4/************************************************************************************函数原型：bool Graph::IsDirectWithoutLoop()***************************函数功能：判断一个图是否是有向无环图***************实现方法：把一步可达矩阵对角线的元素变成0，然后这些矩阵依次平方,直到收敛，如果是有向无环图，则对角线上有非零的元素******************************************************************/bool Graph::IsDirectWithoutLoop(){if(IsUnDirectedGraph()||NodesCount==1)//单个结点或者无向图，就不是有向无环图return false;int Adj[MAXNODES][MAXNODES];int temp[MAXNODES][MAXNODES];int temp1, count=1;for(int k=0;k< NodesCount;k++){for(int l=0;l<NodesCount;l++){if(k!=l)Adj[k][l]=Connect[k][l];elseAdj[k][l]=0;//对角元素为0}}do{SquareMatrix(&Adj[0],&temp[0],NodesCount);//temp=Adj^2count*=2;for(int k=0;k< NodesCount;k++){if(temp[k][k]!=0)return false;for(int l=0;l<NodesCount;l++){temp1=temp[k][l];temp[k][l]=Adj[k][l];Adj[k][l]=temp1;}}}while(count<=NodesCount);//cout<<"如果下面矩阵对角线有非零元素，说明它是有环图"<<endl;printMatrix(&temp[0],NodesCount);for(int n=0;n<NodesCount;n++)if(temp[n][n]!=0)return false;if(!IsFull(&temp[0],NodesCount,0))//如果如果这个矩阵全部是0，那么这是一个哈密顿图cout<<"这是一个哈密顿图！"<<endl;return true;}3.3.2.5 数据结构的操作5/**********************************************************************************************************************************************************函数原型：void Graph::Prim(int v)***************函数功能：仿照Prim算法，构建最大生成树***************实现方法：从顶点v开始，选择剩下的顶点中与v相连的具有最小权值的边加入到S集合中，然后不断在这两个集合里面找到两个点使得它们之间的权重是这个二分图里面最小的，直到集合S等于原来的顶点集为止******************************************************************/void Graph::Prim(int v){bool IsUsed[MAXNODES];//标记这个点是在哪个集合中float max=0;//记录最大权值int i,j,k,col,row;for(i=0;i<NodesCount;i++)//NodesCount次循环IsUsed[i]=false;//初始化IsUsed[v]=true;for(i=1;i<NodesCount;i++){max=0;for(j=0;j<NodesCount;j++)for(k=0;k<NodesCount;k++)if(k==j) continue;//k!=jelseif(((IsUsed[j]==true&&IsUsed[k]==false)||(IsUsed[j]==false&&IsUsed[k]==true))&&AdjM atrix[j][k]>max&&AdjMatrix[j][k]<INF){//在两个集合里挑出两个元素，使得它们之间权值尽可能大max=AdjMatrix[j][k];//更新max的值row=j;col=k;}IsUsed[row]=IsUsed[col]=true;//更新集合cout<<"("<<row<<","<<col<<")"<<"权值为："<<max<<endl;//输出边和权的构造过程}}3.3.2.6 数据结构的操作6/************************************************************************************函数原型：void Graph::floyd()*********************************实现方法：弗洛伊德算法求任意两个点之间的最短距离******************************************************************/void Graph::floyd(){int A[MAXNODES][MAXNODES];int i,j,k;for(i=0;i<NodesCount;i++)for(j=0;j<NodesCount;j++){A[i][j]=AdjMatrix[i][j];}for(k=0;k<NodesCount;k++)for(int i=0;i<NodesCount;i++)for(int j=0;j<NodesCount;j++)if(A[i][j]>(A[i][k]+A[k][j])){A[i][j]=A[i][k]+A[k][j];}printMatrix(&A[0],NodesCount);}3.3.3算法及程序说明本程序中重要的算法思想是：1.判断一个图是否是连通图的算法，利用矩阵的特点，使得矩阵乘法的运算结果收敛从而快速判断图是否连通。