数据结构图实验报告

合集下载

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

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

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

数据结构实验报告--图

数据结构实验报告--图

数据结构实验报告--图【数据结构实验报告--图】【一、实验目的】本实验旨在掌握图的基本概念、存储结构以及相关操作,并通过实验加深对图的理解。

【二、实验环境】操作系统:Windows 10编程语言:C++开发工具:Dev-C++ 5.11【三、实验内容】1.图的定义与基本概念1.1 图的定义:有向图、无向图1.2 图的基本概念:顶点、边、路径、路径长度2.图的存储结构2.1 邻接矩阵表示法2.2 邻接表表示法3.图的操作3.1 图的创建①手动输入图的顶点和边②从文件中读取图的顶点和边3.2 图的遍历①深度优先遍历(DFS)②广度优先遍历(BFS)3.3 图的最小树① Prim算法② Kruskal算法3.4 图的最短路径① Dijkstra算法② Floyd算法4.实验结果分析4.1 图的创建结果4.2 图的遍历结果4.3 图的最小树结果4.4 图的最短路径结果【四、实验步骤】1.定义图的数据结构和相关操作的函数原型。

2.实现图的存储结构和相关操作的函数实现。

3.开发主程序,包括菜单、用户输入、调用图操作函数等。

4.运行程序,测试各个功能是否正常进行。

5.根据运行结果分析,进行必要的调试和优化。

【五、实验结果】1.图的创建结果:●手动输入图的顶点和边:●顶点数.10●边数.15●从文件中读取图的顶点和边:●顶点数.8●边数.122.图的遍历结果:●深度优先遍历:●遍历路径.1 -> 2 -> 4 -> 5 -> 3●广度优先遍历:●遍历路径.1 -> 2 -> 3 -> 4 -> 53.图的最小树结果:●Prim算法:●最小树顶点集合:{1, 2, 4, 5}●最小树边集合:{(1, 2), (2, 4), (2, 5)}●Kruskal算法:●最小树边集合:{(1, 2), (2, 4), (2, 5)}4.图的最短路径结果:●Dijkstra算法:●从顶点1到其他顶点的最短路径长度:●1 -> 2、2●1 -> 3、5●1 -> 4、4●1 -> 5、6●Floyd算法:●图的最短路径邻接矩阵:●0 2 5 4 6●2 0 3 1 3●5 3 0 5 4●4 1 5 0 2●6 3 4 2 0【附件】无【法律名词及注释】1.顶点:图中的一个节点,可以表示实体或事件。

数据结构图的实验报告

数据结构图的实验报告

数据结构图的实验报告数据结构图的实验报告引言:数据结构图是计算机科学中重要的概念之一。

它是一种用图形表示数据元素之间关系的数据结构,广泛应用于算法设计、程序开发和系统优化等领域。

本实验报告旨在介绍数据结构图的基本原理、实验过程和结果分析。

一、实验目的本次实验的主要目的是掌握数据结构图的基本概念和操作方法,以及通过实验验证其在解决实际问题中的有效性。

具体而言,我们将通过构建一个社交网络关系图,实现对用户关系的管理和分析。

二、实验方法1. 确定数据结构在本次实验中,我们选择了无向图作为数据结构图的基础。

无向图由顶点集和边集组成,每条边连接两个顶点,且没有方向性。

2. 数据输入为了模拟真实的社交网络,我们首先需要输入一组用户的基本信息,如姓名、年龄、性别等。

然后,根据用户之间的关系建立边,表示用户之间的交流和联系。

3. 数据操作基于构建好的数据结构图,我们可以进行多种操作,如添加用户、删除用户、查询用户关系等。

这些操作将通过图的遍历、搜索和排序等算法实现。

三、实验过程1. 数据输入我们首先创建一个空的无向图,并通过用户输入的方式逐步添加用户和用户关系。

例如,我们可以输入用户A和用户B的姓名、年龄和性别,并建立一条边连接这两个用户。

2. 数据操作在构建好数据结构图后,我们可以进行多种操作。

例如,我们可以通过深度优先搜索算法遍历整个图,查找与某个用户具有特定关系的用户。

我们也可以通过广度优先搜索算法计算某个用户的社交网络影响力,即与该用户直接或间接相连的其他用户数量。

3. 结果分析通过实验,我们可以观察到数据结构图在管理和分析用户关系方面的优势。

它能够快速地找到用户之间的关系,帮助我们了解用户的社交网络结构和影响力。

同时,数据结构图也为我们提供了一种可视化的方式来展示用户之间的关系,使得分析更加直观和易于理解。

四、实验结果通过实验,我们成功构建了一个社交网络关系图,并实现了多种数据操作。

我们可以根据用户的姓名、年龄和性别等信息进行查询,也可以根据用户之间的关系进行遍历和排序。

数据结构实验报告--图

数据结构实验报告--图

数据结构实验报告--图
数据结构实验报告--图
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. 实验目的本实验的主要目的是掌握图的基本概念和相关操作,包括图的创建、遍历、搜索和最短路径算法等。

3. 实验环境本实验使用C++语言进行编程,采用图的邻接矩阵表示法进行实现。

4. 实验内容4.1 图的创建在实验中,我们首先需要创建一个图。

通过读取输入文件中的数据,我们可以获得图的顶点数和边数,并根据这些信息创建一个空的图。

4.2 图的遍历图的遍历是指从图的某个顶点出发,按照一定的规则依次访问图中的其他顶点。

常用的图的遍历算法有深度优先搜索(DFS)和广度优先搜索(BFS)。

我们可以通过实验来比较这两种遍历算法的效率和应用场景。

4.3 图的搜索图的搜索是指从图的某个顶点出发,找到与之相关的特定顶点或边。

常用的图的搜索算法有深度优先搜索和广度优先搜索。

在实验中,我们可以通过输入特定的顶点或边,来观察图的搜索算法的执行过程和结果。

4.4 图的最短路径算法图的最短路径算法是指在图中找到两个顶点之间的最短路径。

常用的最短路径算法有迪杰斯特拉算法和弗洛伊德算法。

通过实验,我们可以比较这两种算法的执行效率和应用场景。

5. 实验结果与分析通过实验,我们可以得到以下结论:- 图的邻接矩阵表示法在创建和操作图的过程中具有较高的效率。

- 深度优先搜索算法适用于查找图中的连通分量和回路等问题。

- 广度优先搜索算法适用于查找图中的最短路径和最小生成树等问题。

- 迪杰斯特拉算法适用于求解单源最短路径问题,而弗洛伊德算法适用于求解多源最短路径问题。

6. 实验总结通过本次实验,我们深入学习了数据结构图的基本概念和相关操作。

图作为一种重要的数据结构,具有广泛的应用价值。

在今后的学习和工作中,我们可以运用所学的知识,解决实际问题,提高工作效率。

数据结构实验报告—图

数据结构实验报告—图

《算法与数据结构》课程实验报告一、实验目的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,用以存储图中的边,其矩阵元素个数取决于顶点个数,与边数无关。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。

具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。

2、理解栈和队列的特性,并能够实现其基本操作。

3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。

4、学会使用图的数据结构,并实现图的遍历和相关算法。

二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。

三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。

实现顺序表的初始化、插入、删除和查找操作。

2、链表的实现定义链表的节点结构,包含数据域和指针域。

实现链表的创建、插入、删除和查找操作。

(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。

实现栈的入栈、出栈和栈顶元素获取操作。

2、队列的实现采用循环队列的方式实现队列的数据结构。

完成队列的入队、出队和队头队尾元素获取操作。

(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。

2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。

3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。

(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。

删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。

2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。

(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。

入栈和出栈操作的时间复杂度均为 O(1)。

2、队列队列的特点是先进先出,常用于排队、任务调度等场景。

数据结构--图的实验报告

数据结构--图的实验报告

图的实验报告班级:电子091 学号:0908140620 姓名:何洁编号:19(一)实验要求创建一个图。

能够实现图的输入,插入顶点和边,利用队列进行深度和广度遍历。

(二)需求分析功能:1,输入图的信息;2,插入一个顶点;3插入一个边;4,删除一个顶点;5,删除一个边;6,深度优先遍历;7,广度优先遍历;8退出。

(三)概要设计本程序采用的是模板类,抽象数据类型有:T,E。

类:template <class T,class E>class Graphmtx {friend istream & operator>>(istream& in,Graphmtx<T, E>& G);friend ostream & operator<<(ostream& out, Graphmtx<T, E>& G);//输出public:Graphmtx(int sz=30, E max=0); //构造函数~Graphmtx () //析构函数{ delete []VerticesList; delete []Edge; }T getValue (int i) {//取顶点i 的值, i 不合理返回0return i >= 0 && i <= numVertices ?V erticesList[i] : NULL;}E getWeight (int v1, int v2) { //取边(v1,v2)上权值return v1 != -1 && v2 != -1 ? Edge[v1][v2] : 0;}int NumberOfEdges(){return numEdges;} //返回当前边数int NumberOfVertices(){return numVertices;} //返回当前顶点int getFirstNeighbor (int v);//取顶点v 的第一个邻接顶点int getNextNeighbor (int v, int w);//取v 的邻接顶点w 的下一邻接顶点bool insertVertex (const T& vertex);//插入顶点vertexbool insertEdge (int v1, int v2, E cost);//插入边(v1, v2),权值为costbool removeVertex (int v);//删去顶点v 和所有与它相关联的边bool removeEdge (int v1, int v2);//在图中删去边(v1,v2)int getVertexPos (T vertex) {//给出顶点vertex在图中的位置for (int i = 0; i < numVertices; i++)if (VerticesList[i] == vertex) return i;return -1;}//int numVertexPos(T vertex);private:int maxVertices;int numEdges;int numVertices;T *VerticesList; //顶点表E **Edge; //邻接矩阵const E maxWeight;};(四)详细设计函数通过调用图类中的函数实现一些功能。

数据结构 实验报告

数据结构 实验报告

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

二、实验环境本次实验使用的编程语言为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. 实验内容我们选择了顺序表和链表两种线性表的实现方式,并实现了插入、删除和查找等基本操作。

通过实验,我们发现顺序表适用于元素个数较少、频繁查找的情况,而链表适用于插入和删除操作较多、元素个数不确定的情况。

3. 实验心得通过实验一,我们深刻认识到数据结构的不同实现方式对算法的影响。

选择合适的数据结构可以提高算法效率,提高程序的性能。

同时,我们也意识到了在实际应用中,根据问题的具体特点选择不同的数据结构才能得到最优解。

三、实验二:栈与队列的应用本实验旨在通过实现和应用栈和队列的基本操作,掌握栈和队列的特性及其在实际应用中的作用。

2. 实验内容我们分别实现了顺序栈、链式栈、顺序队列和链式队列,并实现了入栈、出栈、入队和出队等基本操作。

我们发现栈适用于实现回溯算法、递归算法等,而队列适用于广度优先搜索、线程池等场景。

3. 实验心得通过实验二,我们进一步理解了栈和队列在实际编程中的运用。

它们提供了方便的数据结构,帮助我们解决了许多实际问题。

同时,实验过程中,我们也发现了栈溢出的问题,意识到了合理管理栈空间的重要性。

四、实验三:树与二叉树的实现与应用1. 实验目的本实验旨在通过实现和应用树和二叉树的基本操作,掌握树和二叉树的存储结构和算法。

2. 实验内容我们实现了树和二叉树的基本操作,包括创建、插入、删除和遍历等。

通过实验,我们发现树在表示具有部分层次结构的问题时更合适,而二叉树在表示递归结构时更加方便。

通过实验三,我们深入理解了树和二叉树的特性及其应用。

树和二叉树是许多高级数据结构的基础,熟练掌握它们的操作对于解决实际问题非常重要。

数据结构图实验报告

数据结构图实验报告

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.通过本次试验让我对图的遍历以及图的深度和广度优先搜索有了更深刻的记忆和理解,将课本理论的知识得以实践。

数据结构 图实验报告

数据结构 图实验报告

数据结构图实验报告数据结构图实验报告引言:数据结构是计算机科学中非常重要的一个概念,它用于存储和组织数据,使得数据的操作更加高效和方便。

图是一种常见的数据结构,它由节点和边组成,用于表示各种实际问题中的关系和连接。

本实验旨在通过实际操作,深入理解图的基本概念和常见操作。

实验目的:1. 理解图的基本概念和特性;2. 掌握图的存储结构和基本操作;3. 实现图的遍历算法;4. 分析图的应用场景。

实验过程:1. 图的存储结构:在本次实验中,我们选择邻接矩阵来存储图。

邻接矩阵是一个二维数组,其中行和列分别表示图中的节点,数组元素表示节点之间的边的关系。

具体而言,如果节点i和节点j之间存在边,则邻接矩阵中的第i行第j列元素为1;否则为0。

2. 图的基本操作:在实验中,我们实现了以下几个图的基本操作:- 添加节点:通过向邻接矩阵中添加一行一列,并设置对应的边的关系,来添加一个节点;- 添加边:通过修改邻接矩阵中对应元素的值,来添加一条边;- 删除节点:通过删除邻接矩阵中对应行和列,并更新其他节点的索引,来删除一个节点;- 删除边:通过修改邻接矩阵中对应元素的值,来删除一条边;- 查找节点:通过遍历邻接矩阵,找到对应节点的索引;- 查找边:通过遍历邻接矩阵,找到对应边的关系。

3. 图的遍历算法:在实验中,我们实现了深度优先搜索(DFS)和广度优先搜索(BFS)两种图的遍历算法。

DFS通过递归的方式,先访问当前节点,再依次访问相邻节点,直到所有节点都被访问。

BFS则通过队列的方式,先访问当前节点,再依次访问当前节点的相邻节点,直到所有节点都被访问。

实验结果:通过实验,我们成功实现了图的存储结构和基本操作,并且正确实现了DFS和BFS两种遍历算法。

我们对不同规模的图进行了测试,并分析了算法的时间复杂度。

实验结果表明,邻接矩阵的存储结构在添加和删除节点时的时间复杂度较高,而在查找节点和边时的时间复杂度较低。

DFS和BFS的时间复杂度都为O(V+E),其中V表示节点数,E表示边数。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、引言数据结构是计算机科学中的重要概念,它涉及到组织和管理数据的方式和算法。

数据结构实验是计算机科学专业的必修实践课程之一,通过实验,我们可以探索不同的数据结构类型,并理解它们的优势和应用。

本报告旨在总结我在数据结构实验中的学习和实践经验。

二、实验目的本次实验的主要目的是熟练掌握线性表、二叉树和图等常见数据结构的构建与操作方法。

通过编写代码,我们可以加深对这些数据结构的理解并且通过实验验证其性能。

三、实验过程1.线性表实验:在这一部分,我们使用C++语言实现了顺序表和链表两种线性表的数据结构,并比较了它们在插入、删除、查找等操作上的性能差异。

2.二叉树实验:我们在实验中实现了二叉树的构建和遍历算法,包括前序遍历、中序遍历和后序遍历。

通过实验,我们发现不同的遍历算法对于不同的问题有不同的效果。

3.图实验:本次实验中,我们实现了图的邻接矩阵和邻接表两种存储结构,并比较了它们在图的遍历和搜索等操作上的性能差异。

同时,我们还实现了最小生成树和最短路径算法,这些算法对实际应用具有重要意义。

四、实验结果根据我们的实验结果,我们可以得出以下结论:1.对于插入和删除等频繁变动的操作,链表比顺序表更适合,因为链表的插入和删除操作时间复杂度为O(1),而顺序表的插入和删除操作时间复杂度为O(n)。

2.在二叉树的遍历中,前序遍历是最简单和常用的一种方式,而中序遍历和后序遍历在某些特定情况下更有用。

例如,在寻找路径上的节点时,后序遍历可以更方便地找出叶子节点。

3.在图的存储中,邻接表比邻接矩阵更节省空间,特别在稀疏图的情况下。

而邻接矩阵在搜索操作中更高效,因为邻接矩阵可以在O(1)的时间内检查两个节点之间是否存在边。

4.最小生成树和最短路径算法在实际生活中有很多应用,例如在城市规划和网络布线中。

通过实验可以发现,Prim算法和Dijkstra算法都可以有效地解决这些问题。

五、实验总结通过本次实验,我对线性表、二叉树和图等常见数据结构有了更深入的了解,并且通过实践中的编码和测试,提高了我的编程能力和问题解决能力。

数据结构实验报告--图

数据结构实验报告--图

.数据结构实验报告图一、实验目的1、熟悉图的结构和相关算法。

二、实验内容及要求1、编写创建图的算法。

2、编写图的广度优先遍历、深度优先遍历、及求两点的简单路径和最短路径的算法。

三、算法描述1、图的邻接表存储表示:对图的每个顶点建立一个单链表,第i个单链表表示所有依附于第i个点的边(对于有向图表示以该顶点为尾的弧);链表的每个节点存储两个信息,该弧指向的顶点在图中的位置(adjvex)和指向下一条弧的指针(nextarc)。

每个连表的头结点存储顶点的数据:顶点信息(data)和指向依附于它的弧的链表域。

存储表示如下:typedef struct ArcNode {int adjvex; // 该弧所指向的顶点的位置struct ArcNode *nextarc;// 指向下一条弧的指针// InfoType *info; // 该弧相关信息的指针} ArcNode;typedef struct VNode {char data; // 顶点信息int data2;int sngle;ArcNode *firstarc;// 指向第一条依附该顶点的弧} VNode, AdjList[MAX_NUM];typedef struct {AdjList vertices;int vexnum, arcnum;int kind; // 图的种类标志} ALGraph;2、深度优先搜索:假设初始态是图中所有定点未被访问,从图中的某个顶点v开始,访问此顶点,然后依次从v的未访问的邻接点出发深度优先遍历,直至途中所有和v有相同路径的点都被访问到;若图中仍有点未被访问,则从图中另选一个未被访问的点作为起点重复上述过程,直到图中所有点都被访问到。

为了便于区分途中定点是否被访问过,需要附设一个访问标致数组visited [0..n-1],将其初值均设为false,一旦某个顶点被访问,将对应的访问标志赋值为true。

2、广度优先搜索:假设初始态是图中所有顶点未被访问,从图中的某个顶点v开始依次访问v的各个未被访问的邻接点,然后分别从这些邻接点出发以此访问他们的邻接点,并使“先被访问的邻接顶点”先于“后被访问的邻接顶点”被访问,直至图中所有已被访问过的顶点的邻接顶点都被访问。

数据结构图的实验报告

数据结构图的实验报告

数据结构图的实验报告
实验目的:学习并掌握数据结构图的基本知识和应用,了解其在程序设计中的重要性和作用。

实验环境:Windows10操作系统,CodeBlocks编译器
实验步骤:
1. 学习数据结构图的基本知识,包括用图形表示数据结构和数据结构之间的关系,以及不同类型的数据结构图的用途和特点。

2. 在CodeBlocks编译器中新建工程,建立一个以图形方式显
示树形结构的简单程序。

3. 建立一个树形结构示例程序,包括输入树中节点的数据和节点之间的关系,并在程序中显示树形结构图。

4. 对程序进行调试和测试,检查程序的正确性和稳定性。

5. 对程序进行优化,尽可能提高程序的运行效率和性能。

实验结果:
经过以上步骤的操作和测试,程序能够正确地显示树形结构,并在输入节点数据时自动建立节点间的关系,从而实现了树形结构图的基本功能。

此外,程序还具有调试和优化的能力,可以进一步提高其稳定性和性能。

实验结论:
学习并掌握数据结构图的基本知识和应用,不仅可以提高程序设计的效率和质量,还可以更好地理解程序运行的机理和原理,从而更好地应用和开发各种应用程序和系统。

因此,数据结构图在计算机科学和工程中具有重要的作用和价值。

数据结构实验报告 图

数据结构实验报告 图

数据结构实验报告图一、实验目的本次实验的主要目的是深入理解和掌握图这种数据结构的基本概念、存储结构和相关算法,并通过实际编程实现来提高对图的操作和应用能力。

二、实验环境本次实验使用的编程语言为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)。

数据结构图实验报告

数据结构图实验报告

数据结构图实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构图的基本概念、原理和操作方法,通过实际编程和操作,提高对数据结构的应用能力和解决问题的能力。

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

三、实验内容(一)线性表1、顺序表实现顺序表的创建、插入、删除、查找等基本操作。

分析顺序表在不同操作下的时间复杂度。

2、链表实现单链表、双向链表的创建、插入、删除、查找等基本操作。

比较单链表和双向链表在操作上的优缺点。

(二)栈和队列1、栈实现顺序栈和链式栈。

用栈解决表达式求值问题。

2、队列实现顺序队列和链式队列。

用队列模拟银行排队问题。

(三)树1、二叉树实现二叉树的创建、遍历(前序、中序、后序)。

计算二叉树的深度和节点数。

2、二叉搜索树实现二叉搜索树的插入、删除、查找操作。

分析二叉搜索树的性能。

(四)图1、图的存储实现邻接矩阵和邻接表两种图的存储方式。

比较两种存储方式的优缺点。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

用图的遍历解决最短路径问题。

四、实验步骤(一)线性表1、顺序表定义一个数组来存储顺序表的元素,并使用一个变量记录当前表的长度。

插入操作时,需要判断插入位置是否合法,如果合法则将插入位置后的元素依次向后移动一位,然后将新元素插入指定位置。

删除操作时,先判断删除位置是否合法,合法则将删除位置后的元素依次向前移动一位,并更新表的长度。

查找操作通过遍历数组来实现。

分析不同操作的时间复杂度,插入和删除操作在最坏情况下为O(n),查找操作在平均情况下为 O(n/2)。

2、链表对于单链表,定义一个节点结构体,包含数据域和指向下一个节点的指针域。

通过操作指针来实现插入、删除和查找操作。

双向链表则在节点结构体中增加指向前一个节点的指针,使得操作更加灵活,但也增加了空间复杂度。

比较单链表和双向链表在插入、删除操作中指针的调整过程,得出双向链表在某些情况下更方便,但空间开销较大的结论。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过本次实验,旨在加深对常见数据结构(如数组、链表、栈、队列、树、图等)的理解和运用,提高编程能力和问题解决能力,培养算法设计和分析的思维。

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

三、实验内容1、数组与链表的实现与操作分别实现整数数组和整数链表的数据结构。

实现数组和链表的插入、删除、查找操作,并比较它们在不同操作下的时间复杂度。

2、栈与队列的应用用数组实现栈结构,用链表实现队列结构。

模拟栈的入栈、出栈操作和队列的入队、出队操作,解决实际问题,如表达式求值、任务调度等。

3、二叉树的遍历构建二叉树的数据结构。

实现先序遍历、中序遍历和后序遍历三种遍历算法,并输出遍历结果。

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

实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法,并分析它们的时间复杂度。

四、实验步骤1、数组与链表数组的实现:定义一个固定大小的整数数组,通过索引访问和操作数组元素。

链表的实现:定义链表节点结构体,包含数据和指向下一个节点的指针。

插入操作:对于数组,若插入位置在末尾,直接赋值;若不在末尾,需移动后续元素。

对于链表,找到插入位置的前一个节点,修改指针。

删除操作:数组需移动后续元素,链表修改指针即可。

查找操作:数组通过索引直接访问,链表需逐个节点遍历。

2、栈与队列栈的实现:用数组模拟栈,设置栈顶指针。

队列的实现:用链表模拟队列,设置队头和队尾指针。

入栈和出栈操作:入栈时,若栈未满,将元素放入栈顶,栈顶指针加 1。

出栈时,若栈不为空,取出栈顶元素,栈顶指针减 1。

入队和出队操作:入队时,在队尾添加元素。

出队时,取出队头元素,并更新队头指针。

3、二叉树构建二叉树:采用递归方式创建二叉树节点。

先序遍历:先访问根节点,再递归遍历左子树,最后递归遍历右子树。

中序遍历:先递归遍历左子树,再访问根节点,最后递归遍历右子树。

数据结构图实验报告汇总

数据结构图实验报告汇总

一、实验目的和要求(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出发的所有深度优先遍历序列。

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

数据结构教程
上机实验报告
实验七、图算法上机实现
一、实验目的:
1.了解熟知图的定义和图的基本术语,掌握图的几种存储结构。

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

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

二、实验内容:
1.建立无向图的邻接矩阵
2.图的深度优先搜索
3.图的广度优先搜索
三、实验步骤及结果:
1.建立无向图的邻接矩阵:
1)源代码:
#include ""
#include ""
#define MAXSIZE 30
typedef struct
{
char
vertex[MAXSIZE];
ertex=i; irstedge=NULL; irstedge; irstedge=p;
p=(EdgeNode*)malloc(sizeof(EdgeNode));
p->adjvex=i; irstedge; irstedge=p;
}
}
int visited[MAXSIZE]; ertex); irstedge;
ertex=i; irstedge=NULL; irstedge;irstedge=p;
p=(EdgeNode *)malloc(sizeof(EdgeNode));
p->adjvex=i; irstedge; irstedge=p;
}
}
typedef struct node
{
int data;
struct node *next;
}QNode; ertex); irstedge;ertex); //输出这个邻接边结点的顶点信息
visited[p->adjvex]=1; //置该邻接边结点为访问过标志
In_LQueue(Q,p->adjvex); //将该邻接边结点送人队Q
}
p=p->next;//在顶点j的邻接表中查找j的下一个邻接边结点
}
}
}
void main()
{
int e,n;
VertexNode g[MAXSIZE];//定义顶点表结点类型数组g
LQueue *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)运行结果:
三、实验总结:
1.通过本次试验让我对图的遍历以及图的深度和广度优先搜索有了更深刻的记忆和理解,将课本理论的知识得以实践。

2.此次试验在书中已经对它的各个运算有了分析和讲解,结合
课本与实验让我理解了图的各个概念与重点知识点。

相关文档
最新文档