数据结构实验———图实验报告
《数据结构》实验报告
苏州科技学院数据结构(C语言版)实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想,原理和算法描述 (3)二、源程序及注释(打包上传) (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想,原理和算法描述 (8)二、源程序及注释(打包上传) (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想,原理和算法描述 (11)二、源程序及注释(打包上传) (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (12)实验四图 (13)一、程序设计的基本思想,原理和算法描述 (13)二、源程序及注释(打包上传) (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想,原理和算法描述 (17)二、源程序及注释(打包上传) (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想,原理和算法描述 (20)二、源程序及注释(打包上传) (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (24)实验一线性表一、程序设计的基本思想,原理和算法描述:程序的主要分为自定义函数、主函数。
数据结构_地图颜色填充问题
《数据结构》实验报告一、实验题目数据结构——期末综合实验——地图填色问题二、问题描述1976年。
美国科学家APPEL和HAKEN利用计算机证明了:对一张地图,可以用不超过4种颜色对其填色,使得相邻的区域填上不同的颜色。
要求输入一张行政区地图,用4种颜色对其填色,要求相邻的行政区域内没有相同的颜色,给出所有的填色方案,并统计方案个数。
三、数据描述首先考虑如何存储行政区域图,由于邻接矩阵能更好地描述各行政区之间的关系,所以采用邻接矩阵G来存储地图。
G[ I , J ]=1 表示I ,J 两个行政区域相邻,为0表示不相邻可采用二维数组来表示邻接矩阵G;另外设一数组COLOR[I]记录各行政区域所填颜色,分别取值为{1(红色),2(黄色),3(蓝色),4(绿色)};数据描述如下:INT G[N][N];INT COLOR[N+1];四、概要设计(1)全局变量定义#define MAX_VERTEX_NUM 26 // 最大行政区域个数//------------------------------- 邻接矩阵数据类型的定义--------------------------------typedef struct{char vexs[MAX_VERTEX_NUM]; // 行政区域-顶点向量int acrs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];// 邻接矩阵int vexnum; // 地图当前行政区域个数}Graph ;int Color[MAX_VERTEX_NUM+1]; // 地图行政区域填充的颜色存储数组long int Count=0; // 统计总共的填色方案个数(2)本程序主要包含6个函数:•主函数main()•创建地图及行政区域的邻接矩阵Create_Graph ()•显示行政区域的邻接矩阵关系Printf_Graph ()•对地图行政区域进行各种方案着色的显Print_Color ()•判断这个颜色对第n行政区域能不能满足要求Same_Color()各函数间调用关系如下:Create_GraphPrintf_GraphMain()Load_ColorSame_ColorPrint_Color(3)主函数的伪码main(){定义一个邻接矩阵G;创建地图及行政区域的邻接矩阵;显示行政区域的邻接矩阵关系;对地图进行填充颜色;改变颜色,显示多种方案;}五、详细设计//------------------------------- 邻接矩阵数据类型的定义--------------------------------#define MAX_VERTEX_NUM 26 // 最大行政区域个数typedef struct{char vexs[MAX_VERTEX_NUM]; // 行政区域-顶点向量int acrs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];// 邻接矩阵int vexnum; // 地图当前行政区域个数}Graph ;/**************************************************************************************** *函数:Create_Graph*功能:建立地图的邻接矩阵*说明:输入参数Graph *G本函数很好的完成了地图的创建以及行政区域之间的存储。
数据结构图的实验报告
数据结构图的实验报告数据结构图的实验报告引言:数据结构图是计算机科学中重要的概念之一。
它是一种用图形表示数据元素之间关系的数据结构,广泛应用于算法设计、程序开发和系统优化等领域。
本实验报告旨在介绍数据结构图的基本原理、实验过程和结果分析。
一、实验目的本次实验的主要目的是掌握数据结构图的基本概念和操作方法,以及通过实验验证其在解决实际问题中的有效性。
具体而言,我们将通过构建一个社交网络关系图,实现对用户关系的管理和分析。
二、实验方法1. 确定数据结构在本次实验中,我们选择了无向图作为数据结构图的基础。
无向图由顶点集和边集组成,每条边连接两个顶点,且没有方向性。
2. 数据输入为了模拟真实的社交网络,我们首先需要输入一组用户的基本信息,如姓名、年龄、性别等。
然后,根据用户之间的关系建立边,表示用户之间的交流和联系。
3. 数据操作基于构建好的数据结构图,我们可以进行多种操作,如添加用户、删除用户、查询用户关系等。
这些操作将通过图的遍历、搜索和排序等算法实现。
三、实验过程1. 数据输入我们首先创建一个空的无向图,并通过用户输入的方式逐步添加用户和用户关系。
例如,我们可以输入用户A和用户B的姓名、年龄和性别,并建立一条边连接这两个用户。
2. 数据操作在构建好数据结构图后,我们可以进行多种操作。
例如,我们可以通过深度优先搜索算法遍历整个图,查找与某个用户具有特定关系的用户。
我们也可以通过广度优先搜索算法计算某个用户的社交网络影响力,即与该用户直接或间接相连的其他用户数量。
3. 结果分析通过实验,我们可以观察到数据结构图在管理和分析用户关系方面的优势。
它能够快速地找到用户之间的关系,帮助我们了解用户的社交网络结构和影响力。
同时,数据结构图也为我们提供了一种可视化的方式来展示用户之间的关系,使得分析更加直观和易于理解。
四、实验结果通过实验,我们成功构建了一个社交网络关系图,并实现了多种数据操作。
我们可以根据用户的姓名、年龄和性别等信息进行查询,也可以根据用户之间的关系进行遍历和排序。
数据结构试验报告-图的基本操作
中原工学院《数据结构》实验报告学院:计算机学院专业:计算机科学与技术班级:计科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实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。
2、理解栈和队列的特性,并能够实现其基本操作。
3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。
4、学会使用图的数据结构,并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。
三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构,包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。
删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。
(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出,常用于排队、任务调度等场景。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为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 根据姓名进行查找;返回此学生的学号和成绩;4 根据指定的位置可返回相应的学生信息学号;姓名;成绩;5 给定一个学生信息;插入到表中指定的位置;6 删除指定位置的学生记录;7 统计表中学生个数..三、实验环境Visual C++四、程序分析与实验结果#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<string.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status; // 定义函数返回值类型typedef struct{char num10; // 学号char name20; // 姓名double grade; // 成绩}student;typedef student ElemType;typedef struct LNode{ElemType data; // 数据域struct LNode *next; //指针域}LNode;*LinkList;Status InitListLinkList &L // 构造空链表L {L=struct LNode*mallocsizeofstruct LNode; L->next=NULL;return OK;}Status GetElemLinkList L;int i;ElemType &e // 访问链表;找到i位置的数据域;返回给 e{LinkList p;p=L->next;int j=1;whilep&&j<i{p=p->next;++j;}ifp||j>i return ERROR;e=p->data;return OK;}Status SearchLNode L;char str;LinkList &p // 根据名字查找{p=L.next;whilep{ifstrcmpp->;str==0return OK;p=p->next;}return ERROR;}Status ListInsertLinkList L;int i;ElemType e // 在i个位置插入某个学生的信息{LinkList p;s;p=L;int j=0;whilep&&j<i-1{p=p->next;++j;}ifp||j>i-1 return ERROR;s=struct LNode*mallocsizeofLNode;s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDeleteLinkList p;int i // 删除i位置的学生信息{int j=0;whilep->next&&j<i-1{p=p->next;++j;}ifp->next||j>i-1 return ERROR;LinkList q;q=p->next;p->next=q->next;delete q;return OK;}void InputElemType *e{printf"姓名:"; scanf"%s";e->name;printf"学号:"; scanf"%s";e->num;printf"成绩:"; scanf"%lf";&e->grade;printf"输入完成\n\n";}void OutputElemType *e{printf"姓名:%-20s\n学号:%-10s\n成绩:%-10.2lf\n\n";e->name;e->num;e->grade;}int main{LNode L;LinkList p;ElemType a;b;c;d;printf"\n********************************\n\n";puts"1. 构造链表";puts"2. 录入学生信息";puts"3. 显示学生信息";puts"4. 输入姓名;查找该学生";puts"5. 显示某位置该学生信息";puts"6. 在指定位置插入学生信息";puts"7. 在指定位置删除学生信息";puts"8. 统计学生个数";puts"0. 退出";printf"\n********************************\n\n"; int x;choose=-1;whilechoose=0{puts"请选择:";scanf"%d";&choose;switchchoose{case 1:ifInitListpprintf"成功建立链表\n\n";elseprintf"链表建立失败\n\n";break;case 2:printf"请输入要录入学生信息的人数:";scanf"%d";&x;forint i=1;i<=x;i++{printf"第%d个学生:\n";i;Input&a;ListInsert&L;i;a;}break;case 3:forint i=1;i<=x;i++{GetElem&L;i;b;Output&b;}break;case 4:char s20;printf"请输入要查找的学生姓名:";scanf"%s";s;ifSearchL;s;pOutput&p->data;elseputs"对不起;查无此人";puts"";break;case 5:printf"请输入要查询的位置:";int id1;scanf"%d";&id1;GetElem&L;id1;c;Output&c;break;case 6:printf "请输入要插入的位置:";int id2;scanf"%d";&id2;printf"请输入学生信息:\n";Input&d;ifListInsert&L;id2;d{x++;puts"插入成功";puts"";}else{puts"插入失败";puts"";}break;case 7:printf"请输入要删除的位置:";int id3;scanf"%d";&id3;ifListDelete&L;id3{x--;puts"删除成功";puts"";}else{puts"删除失败";puts"";}break;case 8:printf"已录入的学生个数为:%d\n\n";x;break;}}printf"\n\n谢谢您的使用;请按任意键退出\n\n\n"; system"pause";return 0;}用户界面:(1)根据指定学生个数;逐个输入学生信息:(2)逐个显示学生表中所有学生的相关信息:(3)根据姓名进行查找;返回此学生的学号和成绩:(4)根据指定的位置可返回相应的学生信息学号;姓名;成绩:(5)给定一个学生信息;插入到表中指定的位置:(6)删除指定位置的学生记录:(7)统计表中学生个数:五、实验总结数据结构是一门专业技术基础课..它要求学会分析研究计算机加工的数据结构的特性;以便为应用涉及的数据选择适当的逻辑结构;存储结构及相应的算法;并初步掌握算法的时间分析和空间分析技术..不仅要考虑具体实现哪些功能;同时还要考虑如何布局;这次的实验题目是根据我们的课本学习进程出的;说实话;我并没有真正的读懂书本的知识;所以刚开始的时候;感到很棘手;于是又重新细读课本;这一方面又加强了对书本的理解;在这上面花费了一些心血;觉得它并不简单;是需要花大量时间来编写的....在本次实验中;在程序构思及设计方面有了较大的锻炼;能力得到了一定的提高..。
图的遍历数据结构实验报告
图的遍历数据结构实验报告正文:1·引言本实验报告旨在介绍图的遍历数据结构实验的设计、实现和结果分析。
图是一种常见的数据结构,用于表示对象之间的关系。
图的遍历是指系统地访问图的每个节点或边的过程,以便获取所需的信息。
在本次实验中,我们将学习并实现图的遍历算法,并分析算法的效率和性能。
2·实验目标本实验的主要目标是实现以下几种图的遍历算法:●深度优先搜索(DFS)●广度优先搜索(BFS)●拓扑排序3·实验环境本实验使用以下环境进行开发和测试:●操作系统:Windows 10●编程语言:C++●开发工具:Visual Studio 20194·实验设计与实现4·1 图的表示我们采用邻接矩阵的方式来表示图。
邻接矩阵是一个二维数组,用于表示图中节点之间的关系。
具体实现时,我们定义了一个图类,其中包含了节点个数、边的个数和邻接矩阵等属性和方法。
4·2 深度优先搜索算法(DFS)深度优先搜索是一种经典的图遍历算法,它通过递归或栈的方式实现。
DFS的核心思想是从起始节点开始,尽可能深地访问节点,直到达到最深的节点或无法继续访问为止。
我们实现了一个递归版本的DFS算法,具体步骤如下:●从起始节点开始进行递归遍历,标记当前节点为已访问。
●访问当前节点的所有未访问过的邻接节点,对每个邻接节点递归调用DFS函数。
4·3 广度优先搜索算法(BFS)广度优先搜索是另一种常用的图遍历算法,它通过队列的方式实现。
BFS的核心思想是从起始节点开始,逐层地遍历节点,先访问离起始节点最近的节点。
我们实现了一个使用队列的BFS算法,具体步骤如下:●将起始节点放入队列,并标记为已访问。
●从队列中取出一个节点,访问该节点并将其所有未访问的邻接节点放入队列。
●重复上述步骤,直到队列为空。
4·4 拓扑排序算法拓扑排序是一种将有向无环图(DAG)的所有节点线性排序的算法。
厦门理工学院数据结构实验2
《数据结构》实验报告实验序号:2 实验项目名称:顺序表的实现四、实验结果与数据处理1.设A、B均为用数组实现的List类型的有序顺序表,试设计一个函数Alternate,从A、B读取值,构件数组C,使得C的值也有序。
要求:用不同的方式实现(至少两种),并比较算法的效率。
(1)运行结果:图1:先合并之后再排序图2:合并时排序(2)问题分析:在这一问题中,A顺序表和B顺序表的合并方法可以分为先将这两个顺序表合并后排序或者在输入时就对其进行比较元素大小排序。
这里第一种方法,因为上一次实验学习过了快速排序,所以这一次我采用了另一种方法——希尔排序,希尔排序法是对直接插入排序法的优化,通过设置一个增量,对原始序列进行分组,对每组用直接插入排序法排序再整合,再缩小增量,周而复始直至增量为1,完成排序,因此又叫“缩小增量排序法”。
希尔排序的算法性能在面对大量数据时会高于快速排序,它的平均时间复杂度为n*log2n,整体范围为n^(1.3—2)之间。
第二种方法是我们在输入时就对新顺序表进行排序,在输入A顺序表的时候我们正常接收数据,而在输入B顺序表时,我们通过遍历一次当前顺序表同时结合插入数据函数来将B顺序表输入的数据放到正确的位置上,来使整个顺序表能够有序,整体时间复杂度为n^2左右,可见第一种方法的算法效率会更高一些。
2.顺序表表示和实现线性表的如下:【要求】(1)实现顺序表的插入、删除、按值查找等基本操作;(2)假设构建的是非递增有序顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同。
(3)设有一元素为整数的线性表L=(a1,a2,a3,…,an),存放在一维数组A[N]中,设计一个算法,以表中an作为参考元素,将该表分为左、右两部分,其中左半部分每个元素小于等于an,右半部分每个元素都大于an, an位于分界位置上(要求结果仍存放在A[N]中)。
(4)分析以上算法的时间复杂性。
图的基本操作实验报告
图的基本操作实验报告图的基本操作实验报告一、引言图是计算机科学中常用的数据结构之一,它由节点和边组成,用于表示事物之间的关系。
图的基本操作是对图进行增、删、改、查等操作,本实验旨在通过编程实现图的基本操作,加深对图的理解。
二、实验目的1. 理解图的基本概念和表示方法;2. 掌握图的基本操作,包括节点的插入、删除,边的添加、删除等;3. 运用图的基本操作解决实际问题。
三、实验方法本实验使用Python编程语言实现图的基本操作。
首先,定义图类,包括图的初始化、节点的插入、删除,边的添加、删除等方法。
然后,根据实际需求设计测试用例,验证图的基本操作的正确性。
四、实验过程1. 图的初始化在图类的初始化方法中,创建一个空的字典用于存储节点和边的信息。
节点用唯一的标识符表示,边用包含两个节点标识符的元组表示。
2. 节点的插入编写节点插入方法,接收节点标识符作为参数,将节点添加到图中。
在添加节点时,需要判断节点是否已存在于图中,如果存在则不进行插入操作。
3. 节点的删除编写节点删除方法,接收节点标识符作为参数,将节点从图中删除。
在删除节点时,需要同时删除与该节点相关的边。
4. 边的添加编写边添加方法,接收两个节点标识符作为参数,将边添加到图中。
在添加边时,需要判断节点是否存在于图中,如果不存在则先进行节点的插入操作。
5. 边的删除编写边删除方法,接收两个节点标识符作为参数,将边从图中删除。
在删除边时,需要判断边是否存在于图中。
6. 测试用例设计设计多个测试用例,包括插入节点、删除节点、添加边、删除边等操作,并验证操作的正确性。
七、实验结果经过多次测试,图的基本操作均能正常运行,符合预期结果。
通过图的基本操作,可以方便地对图进行增、删、改、查等操作,解决实际问题。
八、实验总结通过本次实验,我深入理解了图的基本概念和表示方法,并掌握了图的基本操作。
图作为一种重要的数据结构,在计算机科学中有着广泛的应用,例如社交网络分析、路线规划等领域。
数据结构实验报告图与景区
学生学号实验课成绩
学生实验报告书
实验课程名称数据结构与算法综合实验开课学院计算机科学与技术学院指导教师姓名
学生姓名
学生专业班级
2017-- 2018学年第 2 学期
实验课程名称: 数据结构与算法综合实验
2.综合分析与结论
由于上一次的哈夫曼树没有写很好所以我回去以后有好好学习了一下数据结构,本次实验也比第一次有了经验了,通过与视频的学习我本次把实验全都做出来了。
但在实现的过程中对算法的理解还不够透彻,有待提高。
国开数据结构(本)数据结构课程实验报告
国开数据结构(本)数据结构课程实验报告1. 实验目的本次实验的主要目的是通过实际操作,掌握数据结构的基本概念、操作和应用。
通过对实验内容的了解和实际操作,达到对数据结构相关知识的深入理解和掌握。
2. 实验工具与环境本次实验主要使用C++语言进行编程,需要搭建相应的开发环境。
实验所需的工具和环境包括:C++编译器、集成开发环境(IDE)等。
3. 实验内容本次实验主要包括以下内容:3.1. 实现顺序存储结构的线性表3.2. 实现链式存储结构的线性表3.3. 实现栈和队列的顺序存储结构和链式存储结构3.4. 实现二叉树的顺序存储结构和链式存储结构3.5. 实现图的邻接矩阵和邻接表表示4. 实验步骤实验进行的具体步骤如下:4.1. 实现顺序存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.2. 实现链式存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.3. 实现栈和队列的顺序存储结构和链式存储结构- 定义数据结构- 实现入栈、出栈、入队、出队操作4.4. 实现二叉树的顺序存储结构和链式存储结构- 定义数据结构- 实现插入、删除、查找等操作4.5. 实现图的邻接矩阵和邻接表表示- 定义数据结构- 实现插入、删除、查找等操作5. 实验结果与分析通过对以上实验内容的实现和操作,得到了以下实验结果与分析: 5.1. 顺序存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.2. 链式存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.3. 栈和队列的顺序存储结构和链式存储结构- 实现了栈和队列的入栈、出栈、入队、出队操作- 通过实验数据进行性能分析,得出了相应的性能指标5.4. 二叉树的顺序存储结构和链式存储结构- 实现了二叉树的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.5. 图的邻接矩阵和邻接表表示- 实现了图的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标6. 总结与展望通过本次数据结构课程的实验,我们深入了解并掌握了数据结构的基本概念、操作和应用。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括:1、熟悉常见的数据结构,如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作,如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力,能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性,实现入栈和出栈操作。
队列的先进先出原则,完成入队和出队功能。
3、树的操作二叉树的创建、遍历(前序、中序、后序)。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表:首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。
通过创建链表头节点,并使用循环依次插入新节点,实现了链表的创建。
插入节点时,根据指定位置找到插入点的前一个节点,然后修改指针完成插入操作。
删除节点时,同样找到要删除节点的前一个节点,修改指针完成删除。
实验结果:成功创建、插入和删除了单向链表的节点,并正确输出了链表的内容。
双向链表:双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果:双向链表的各项操作均正常,能够双向遍历链表。
循环链表:使链表的尾节点指向头节点,形成循环。
在操作时需要特别注意循环的边界条件。
实验结果:成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈:使用数组或链表来实现栈。
入栈操作将元素添加到栈顶,出栈操作取出栈顶元素。
实验结果:能够正确进行入栈和出栈操作,验证了栈的后进先出特性。
数据结构图的遍历实验报告doc
数据结构图的遍历实验报告篇一:【数据结构】图的存储和遍历实验报告《数据结构B》实验报告系计算机与电子专业级班姓名学号XX年1 0月 9日1. 上机题目:图的存储和遍历2. 详细设计#include#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define error printf#define QueueSize 30typedef struct{char vexs[GRAPHMAX];int edges[GRAPHMAX][GRAPHMAX];int n,e;}MGraph;int visited[10];typedef struct{int front,rear,count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q) {Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q) {return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x) {if(QueueFull(Q))error("Queue overflow");else{ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;}}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){ error("Queue underflow");return NULL;}else{ temp=Q->data[Q->front]; Q->count--; Q->front=(Q->front+1)%QueueSize; return temp;}}void CreateMGraph(MGraph *G){int i,j,k;char ch1,ch2;printf("\n\t\t请输入定点数,边数并按回车(格式如:3,4):");scanf("%d,%d",&(G->n),&(G->e));for(i=0;in;i++){ getchar();printf("\n\t\t请输入第%d个定点数并按回车:",i+1);scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->edges[i][j]=0;for(k=0;ke;k++){ getchar();printf("\n\t\t请输入第%d条边的顶点序号(格式如:i,j):",k+1);scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->edges[i][j]=1;}}void DFSM(MGraph *G,int i){int j;printf("\n\t\t深度优先遍历序列: %c\n",G->vexs[i]);visited[i]=TRUE;for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) ////////////////DFSM(G,j);}void BFSM(MGraph *G,int k){ int i,j;CirQueue Q;InitQueue(&Q);printf("\n\t\t广度优先遍历序列:%c\n",G->vexs[k]);visited[k]=TRUE;EnQueue(&Q,k);while(!QueueEmpty(&Q)){ i=DeQueue(&Q);for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) { visited[j]=TRUE;EnQueue(&Q,j);}}}void DFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) DFSM(G,i);}void BFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) BFSM(G,i);}void main(){MGraph *G,a;char ch1;int i,j,ch2;G=&a;printf("\n\t\t建立一个有向图的邻接矩阵表示\n");CreateMGraph(G);printf("\n\t\t已建立一个有向图的邻接矩阵存储\n");for(i=0;in;i++){ printf("\n\t\t");for(j=0;jn;j++)printf("%5d",G->edges[i][j]);}getchar();ch1='y';while(ch1=='y'||ch1=='Y'){ 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*0-----退出*");printf("\n\t\t********************************");}} printf("\n\t\t请选择菜单号(0----3)"); scanf("%d",&ch2); getchar(); switch(ch2) { case 1:CreateMGraph(G); printf("\n\t\t图的邻接矩阵存储建立完成\n");break; case 2:DFSTraverseM(G);break; case 3:BFSTraverseM(G);break; case 0:ch1='n';break; default:printf("\n\t\t输出错误!清重新输入!"); }3. 调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?由于实习之初对邻接表的存储结构了解不是很清楚,所以在运行出了一个小错误,即在输出邻接表时,每个结点都少了一个邻接点。
数据结构图实验报告
数据结构图实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构图的基本概念、原理和操作方法,通过实际编程和操作,提高对数据结构的应用能力和解决问题的能力。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容(一)线性表1、顺序表实现顺序表的创建、插入、删除、查找等基本操作。
分析顺序表在不同操作下的时间复杂度。
2、链表实现单链表、双向链表的创建、插入、删除、查找等基本操作。
比较单链表和双向链表在操作上的优缺点。
(二)栈和队列1、栈实现顺序栈和链式栈。
用栈解决表达式求值问题。
2、队列实现顺序队列和链式队列。
用队列模拟银行排队问题。
(三)树1、二叉树实现二叉树的创建、遍历(前序、中序、后序)。
计算二叉树的深度和节点数。
2、二叉搜索树实现二叉搜索树的插入、删除、查找操作。
分析二叉搜索树的性能。
(四)图1、图的存储实现邻接矩阵和邻接表两种图的存储方式。
比较两种存储方式的优缺点。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
用图的遍历解决最短路径问题。
四、实验步骤(一)线性表1、顺序表定义一个数组来存储顺序表的元素,并使用一个变量记录当前表的长度。
插入操作时,需要判断插入位置是否合法,如果合法则将插入位置后的元素依次向后移动一位,然后将新元素插入指定位置。
删除操作时,先判断删除位置是否合法,合法则将删除位置后的元素依次向前移动一位,并更新表的长度。
查找操作通过遍历数组来实现。
分析不同操作的时间复杂度,插入和删除操作在最坏情况下为O(n),查找操作在平均情况下为 O(n/2)。
2、链表对于单链表,定义一个节点结构体,包含数据域和指向下一个节点的指针域。
通过操作指针来实现插入、删除和查找操作。
双向链表则在节点结构体中增加指向前一个节点的指针,使得操作更加灵活,但也增加了空间复杂度。
比较单链表和双向链表在插入、删除操作中指针的调整过程,得出双向链表在某些情况下更方便,但空间开销较大的结论。
大学数据结构实验报告模板
大学数据结构实验报告模板一、实验目的数据结构实验是计算机相关专业课程中的重要实践环节,通过实验可以加深对数据结构理论知识的理解,提高编程能力和解决实际问题的能力。
本次实验的主要目的包括:1、掌握常见数据结构(如数组、链表、栈、队列、树、图等)的基本操作和实现方法。
2、学会运用数据结构解决实际问题,培养算法设计和分析能力。
3、提高程序设计的规范性和代码质量,培养良好的编程习惯。
4、熟悉编程语言(如C、C++、Java 等)的开发环境和调试技巧。
二、实验环境1、操作系统:_____2、编程语言:_____3、开发工具:_____三、实验内容(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构。
实现顺序表的初始化、插入、删除、查找等基本操作。
2、链表的实现定义链表的数据结构(单链表、双向链表或循环链表)。
实现链表的创建、遍历、插入、删除等操作。
(二)栈和队列的实现与应用1、栈的实现定义栈的数据结构。
实现栈的入栈、出栈、栈顶元素获取等操作。
利用栈解决括号匹配、表达式求值等问题。
2、队列的实现定义队列的数据结构。
实现队列的入队、出队、队头元素获取等操作。
利用队列实现广度优先搜索、任务调度等应用。
(三)树的实现与遍历1、二叉树的实现定义二叉树的数据结构(二叉链表或顺序存储)。
实现二叉树的创建、前序遍历、中序遍历、后序遍历。
2、二叉搜索树的实现实现二叉搜索树的插入、删除、查找操作。
3、平衡二叉树(如 AVL 树)的实现(选做)理解平衡二叉树的平衡调整算法。
实现平衡二叉树的插入和删除操作,并保持树的平衡。
(四)图的表示与遍历1、图的邻接矩阵和邻接表表示定义图的数据结构(邻接矩阵或邻接表)。
实现图的创建和初始化。
2、图的深度优先遍历和广度优先遍历实现图的深度优先遍历和广度优先遍历算法。
应用图的遍历解决最短路径、连通性等问题。
(五)排序算法的实现与性能比较1、常见排序算法的实现实现冒泡排序、插入排序、选择排序、快速排序、归并排序等算法。
图的遍历数据结构实验报告
图的遍历数据结构实验报告图的遍历数据结构实验报告1. 实验目的本实验旨在通过使用图的遍历算法,深入理解图的数据结构以及相关算法的运行原理。
2. 实验背景图是一种非线性的数据结构,由顶点和边组成。
图的遍历是指按照某种规则,从图中的一个顶点出发,访问图中的所有顶点且仅访问一次的过程。
3. 实验环境本次实验使用的操作系统为Windows 10,编程语言为Python3.8,使用的图数据结构库为NetworkX。
4. 实验步骤4.1 创建图首先,我们使用NetworkX库创建一个有向图。
通过调用add_nodes_from()方法添加顶点,并调用add_edge()方法添加边,构建图的结构。
4.2 深度优先搜索(DFS)接下来,我们使用深度优先搜索算法来遍历这个图。
深度优先搜索是一种递归的遍历法,从一个顶点开始,沿着深度方向访问图中的顶点,直到不能继续深入为止。
4.3 广度优先搜索(BFS)然后,我们使用广度优先搜索算法来遍历这个图。
广度优先搜索是一种先访问离起始顶点最近的顶点的遍历法,从一个顶点开始,依次访问与之相邻的顶点,直到访问完所有的顶点为止。
5. 实验结果我们根据深度优先搜索和广度优先搜索算法,分别得到了图的遍历结果。
通过实验可以观察到每种遍历方式所访问的顶点顺序以及所需的时间复杂度。
6. 结论通过本次实验,我们了解了图的遍历数据结构及相关算法的原理和实现方式。
深度优先搜索和广度优先搜索算法适用于不同的场景,可以根据具体情况选择合适的算法进行图的遍历。
附件:无附录:本文所涉及的法律名词及注释:- 图:由结点和边组成的非线性数据结构。
- 顶点:图中的每个元素都称为顶点,也称为结点。
- 边:顶点之间的连接关系称为边。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构实验报告目的要求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 InitQueue(LinkQueue &Q){ //初始化队列Q.front =Q.rear =(QueuePtr)malloc(sizeof(QNode));if(!Q.front) exit(OVERFLOW); //存储分配失败Q.front ->next =NULL;}int EnQueue(LinkQueue &Q,QElemType e) //插入元素e为Q的新的队尾元素{QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear =p;return OK;}int DeQueue(LinkQueue &Q,QElemType &e) //删除Q的队头元素,用e返回其值{ if(Q.front ==Q.rear ) return ERROR;QueuePtr p;p=Q.front ->next;e=p->data;Q.front->next=p->next ;if(Q.rear==p) Q.rear =Q.front ;free(p);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 visited[MAX_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/*头结点*/,AdjList[MAX_VERTEX_NUM];typedef struct{ AdjList vertices;int vexnum,arcnum;/*顶点的实际数,边的实际数*/}ALGraph;//建立图的邻接表void creat_link(ALGraph *G){ int i,j;ArcNode *s;printf("请依次输入顶点数、边数:");scanf("%d%d",&G->vexnum,&G->arcnum);for (i=0;i<G->vexnum;i++){ G->vertices[i].data='A'+i;G->vertices[i].firstarc=NULL;}for (i=0;i<G->vexnum;){ printf("请输入顶点的数组坐标(若退出,请输入-1):");scanf("%d",&i);if(i==-1) break;printf("请输入顶点所指向下一个顶点的数组坐标:");scanf("%d",&j);s=(ArcNode *)malloc(sizeof(ArcNode));s->adjvex=j;s->nextarc=G->vertices[i].firstarc;G->vertices[i].firstarc=s;}}// 输出邻接表void visit(ALGraph 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.vertices[i].data);for(p=G.vertices[i].firstarc;p;p=p->nextarc)printf("%3d",p->adjvex);printf("\n");}}// 计算各顶点的度及入度void cacu(ALGraph *G){ArcNode *p;int i;for (i=0;i<G->vexnum;i++){G->vertices[i].degree=0;G->vertices[i].indegree=0;}//度与初度初始化为零for (i=0;i<G->vexnum;i++)for(p=G->vertices[i].firstarc;p;p=p->nextarc){G->vertices[i].degree++;G->vertices[p->adjvex].degree++;G->vertices[p->adjvex].indegree++;}}void print_degree(ALGraph 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.vertices[i].data,G.vertices[i].degree,G.vertices[i].indegree);printf("\n");}// 拓扑排序Status TopologiSort(ALGraph G){int i,count,top=0,stack[50];ArcNode *p;cacu(&G);print_degree(G);printf("\nTopologiSort is \n");for(i=0;i<G.vexnum;i++)if(!G.vertices[i].indegree) stack[top++]=i;count=0;while(top!=0){i=stack[--top];if (count==0) printf("%c",G.vertices[i].data);else printf("-->%c",G.vertices[i].data);count++;for(p=G.vertices[i].firstarc;p;p=p->nextarc)if (!--G.vertices[p->adjvex].indegree)stack[top++]=p->adjvex;}if (count<G.vexnum)return(FALSE); else return(TRUE);}//在图G中寻找第v个顶点的第一个邻接顶点int FirstAdjVex(ALGraph G,int v){if(!G.vertices[v].firstarc) return 0;else return(G.vertices[v].firstarc->adjvex);}//在图G中寻找第v个顶点的相对于u的下一个邻接顶点int NextAdjVex(ALGraph G,int v,int u){ArcNode *p;p=G.vertices[v].firstarc;while(p->adjvex!=u) p=p->nextarc; //在顶点v的弧链中找到顶点u if(p->nextarc==NULL) return 0; //若已是最后一个顶点,返回0else return(p->nextarc->adjvex); //返回下一个邻接顶点的序号}//采用邻接表存储实现无向图的深度优先递归遍历void DFS(ALGraph G,int i){ int w;visited[i]=True; //访问第i个顶点printf("%d->",i);for(w=FirstAdjVex(G,i);w;w=NextAdjVex(G,i,w))if(!visited[w]) DFS(G,w); //对尚未访问的邻接顶点w调用DFS}void DFSTraverse(ALGraph G){ int i;printf("DFSTraverse:");for(i=0;i<G.vexnum;i++) visited[i]=False; //访问标志数组初始化for(i=0;i<G.vexnum;i++)if(!visited[i]) DFS(G,i); //对尚未访问的顶点调用DFS}//按广度优先非递归的遍历图G,使用辅助队列Q和访问标志数组visited void BFSTraverse(ALGraph G){int i,u,w;LinkQueue Q;printf("BFSTreverse:");for(i=0;i<G.vexnum;i++) visited[i]=False; //访问标志数组初始化InitQueue(Q); //初始化队列for(i=0;i<G.vexnum;i++)if(!visited[i]){visited[i]=True; //访问顶点iprintf("%d->",i);EnQueue(Q,i); //将序号i入队列while(!(Q.front ==Q.rear)) //若队列不空,继续{DeQueue(Q,u); //将队头元素出队列并置为ufor(w=FirstAdjVex(G,u);w;w=NextAdjVex(G,u,w))if(!visited[w]) //对u的尚未访问的邻接顶点w进行访问并入队列{ visited[w]=True;printf("%d->",w);EnQueue(Q,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);switch(select){case 1:printf("\n创建一个有向图的邻接表:\n");creat_link(&G);break;case 2:printf("\n输出该邻接表:\n");visit(G);break;case 3:printf("\n输出该有向图的度和入度:\n");cacu(&G);print_degree(G);break;case 4:printf("\n输出该有向图拓扑排序序列:\n");if(!TopologiSort(G))printf("Toposort is not success!");break;case 5:printf("\n创建一个无向图的邻接表: \n");creat_link(&G);break;case 6:printf("\n深度优先递归遍历该无向图: \n");DFSTraverse(G);break;case 7:printf("\n广度优先遍历该无向图:\n");BFSTraverse(G);break;case 0:break;default:printf("输入选项错误!重新输入!\n");}}while(select);}运行结果截图:1.主菜单界面:2.创建一个有向图的领接表3.输出该邻接表4. 在有向图的邻接表的基础上计算各顶点的度,并输出。