数据结构上机实验报告

合集下载

东华大学数据结构上机实验报告

东华大学信息科学与技术学院实验报告实验名称：线性表的基本操作指导教师：学生姓名：学生学号：实验日期：2012/11一、实验目的１、熟悉Ｃ或VC++语言上机环境。

２、会定义线性表的顺序存储结构和链式存储结构。

３、熟悉顺序表和单链表的一些基本操作和应用。

４、加深对线性表的理解，逐步培养解决实际问题的编程能力。

二、实验环境运行Ｃ或VC++的微机。

三、实验内容：分别使用顺序表和单链表存储结构实现以下操作：1.建立线性表L＝｛12,13,21,24,28,31,42,77｝；2.在第5个元素之前插入26；3.删除第5个元素28；4.查找28。

四、实验设计思路及算法流程(一)使用顺序表实现操作:建立顺序表，完成顺序表的基本操作：初始化、插入、删除、输出、查找元素、判线性表是否为空；问题分析：利用顺序表,设计一组输入数据，能够对顺序表进行如下操作：创建一个新的顺序表，实现动态空间分配的初始化；已给定的值插入到指定位置和删除指定位置的值，形成有序顺序表；按值查找，根据给定数据元素的值，查找该元素的位置，对查找结果进行返回；实现顺序表的各个元素的输出；“初始化算法”的操作结果：构造一个空的顺序线性表，对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；“位置插入算法”的初始条件：顺序线性表L已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；其操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1；“位置删除算法”的初始条件：顺序线性表L已存在，1≤i≤ListLength(L) ；其操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 ；“输出算法”的初始条件：顺序线性表L已存在；其操作结果：依次对L的每个数据元素进行输出；“按值查找算法”初始条件：顺序线性表L已存在，元素值为e；其操作结果：返回L 中数据元素值为e的元素位置；线性表的顺序存储结构的定义及其基本操作的参考程序（顺序表）文件一：pubuse. h 是公共使用的常量定义和系统函数调用声明。

数据结构上机实验报告

{if(i%2==0) insert(lb,i/2,la.list[i]); //奇数位次元诩插入lb
else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为：\n\n");
print(lb);
printf("线性表的偶数位次的元素为：\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度：\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】：
建立三个线性表la,lb,lc，对线性表la进行输入，然后利用循环结构对la中奇数位序的元素对lb进行插入操作，对偶数位序的元素对lc进行插入操作，从而得到线性表lb和lc。
【程序代码】：
#include<stdio.h>
#include<malloc.h>

数据结构集中上机实验报告

XX大学信息与计算科学专业2008级《数据结构》集中上机设计题目：迷宫求解（非递归求解）设计时间：2010-2011学年第一学期目录一、实验内容 (2)二、需求分析 (2)三、总体设计 (2)（一）存储结构 (2)（二）流程图 (3)四、详细设计 (3)（一）基本算法解析 (3)（二）为实现算法，需要的象的数据类型 (4)(三)函数的调用关系 (5)（四）算法时间、空间复杂度 (5)五、代码 (5)六、运行结果分析 (10)（一）迷宫路径探索成功 (10)（二）迷宫路径未找到的情况 (13)（三）程序的优缺点与改进 (13)七、参考文献 (14)八、心得体会 (14)一、实验内容任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出。

二、需求分析1、可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；要求使用非递归算法。

2、用户可以根据自己的需求进行输入所需的迷宫，其中1表示迷宫的墙壁，0表示迷宫的通路，从而建立迷宫。

3、可以自行输入迷宫的入口和出口坐标。

4、程序执行的命令包括：（1）构造栈函数。

其中包括了构造空栈InitStack；压入新数据元素Push；栈顶元素出栈Pop。

（2）构造求迷宫路径函数。

其中定义了二维数组maze[M][N]存取迷宫数据；输出找到的通路MazePath。

（3）建立一个迷宫initmaze。

其中包括输入迷宫行数列数以及各行各列；加一圈围墙并输出迷宫。

三、总体设计（一）存储结构：首先用二维数组存储迷宫数据，迷宫数据由用户输入。

一个以链表结构作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。

求得的通路以三元组（i,j,d）形式输出，其中（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向（东南西北所用代表数字，自行定义）。

1．从入口出发，顺着某一个方向进行探索，若能走通，继续往前走，否则沿原路退回，换一个方向继续探索，直至出口位置，求得一条通路。

数据结构上机报告

数据结构上机报告班级：通信工程1405 姓名：李笑阳学号：U201413536一．约瑟夫环1.需求分析①．约瑟夫问题的一种描述是：编号为1，2，……，n点的n个人按顺时针方向围坐一个圈，每人持有一个密码。

一开始选一个正整数作为报数上限值m，从第一个人开始从顺时针方向自1开始报数，报到m时停止。

报到m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始从新从1报数，如此下去，直达所有人出列。

②．基本要求：利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各人的编号。

③．演示程序提示用户输入其总人数，然后依此输入每个人的数字，程序按照出列的顺序输出各人的编号。

测试数据：m的初始值为20；n=7，7个人的密码依次是3，1，7，2，4，8，4，首先m 的值为6（正确的出列顺序为6，1，4，7，2，3，5）2.设计概要①循环链表的结点类型定义typedef struct LNode②．创建链表模块LinkList creatList_L(int n)③．删除链表并释放空间模块void ListDelete_L(LinkList L,int key,int n)④．主函数模块（约瑟夫环的实现）Void main()3.具体代码实现#include<stdio.h>#include<malloc.h>//定义结构体typedef struct LNode{int password,num;struct LNode *next;}LNode,*LinkList;//创建链表LinkList creatList_L(int n){LinkList p,head,q;int i=1,key;head=(LinkList)malloc(sizeof(LNode));p=head;for(i=1;i<=n;i++) //进入循环赋值{scanf("%d",&key);q=p;p=(LinkList)malloc(sizeof(LNode));p->num=i;p->password=key;q->next=p;}p->next=head->next;free(head); ////现在的p节点是列表的尾节点把尾节点的下一个指向头结点//也就是形成了一个环head=p->next;return (head);}//输出并删除列表void ListDelete_L(LinkList L,int key,int n){LinkList p,s;int j=1;while(n>0){p=L;//key是人数上限M==key 现在开始循环叫数叫到M的输出//并从循环链表中删除for(j=1;j<key;j++){s=p;p=p->next;}printf("%2d %5d\n",p->num,p->password);key=p->password;//s是p的上一个节点，现在把s的下一个节点指向p的下一个s->next=p->next;L=p->next;//释放p节点free(p);//链表总数减一，一直到n==0时退出while循环n--;}}void main(){LinkList s;int n,m;printf("请输入总人数N和上限数M:");scanf("%d%d",&n,&m);printf("请输入%d个人的密码:",n);s=creatList_L(n); //调用创建列表printf("序号密码\n");ListDelete_L(s,m,n); //调用输出并删除列表}4.运行分析①．运行结果②．复杂度的分析时间复杂度为O(n2），空间复杂度为O（n）5．实验总结这个算法中的主函数只完成输入输出，其他都是通过调用完成。

数据结构上机实验报告

数据结构上机实验报告学院：电子工程学院专业：信息对抗技术姓名：学号：教师：饶鲜日期：目录实验一线性表 ........................................................................................................ - 4 -一、实验目的.................................................................................................... - 4 -二、实验代码.................................................................................................... - 4 -三、实验结果.................................................................................................. - 14 -四、个人思路.................................................................................................. - 15 - 实验二栈和队列 .................................................................................................. - 15 -一、实验目的.................................................................................................. - 15 -二、实验代码.................................................................................................. - 16 -三、实验结果.................................................................................................. - 24 -四、个人思路.................................................................................................. - 25 - 实验三数组 .......................................................................................................... - 26 -一、实验目的.................................................................................................. - 26 -二、实验代码.................................................................................................. - 26 -三、实验结果.................................................................................................. - 28 -四、个人思路.................................................................................................. - 28 - 实验四树 .............................................................................................................. - 29 -一、实验目的.................................................................................................. - 29 -二、实验代码.................................................................................................. - 29 -三、实验结果.................................................................................................. - 39 -四、个人思路.................................................................................................. - 39 -实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验代码1．设有一个线性表E={e1, e2, … , e n-1, e n}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ e n, e n-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，并且用顺序表和单链表两种方法表示，分别用两个程序来完成。

数据结构上机实习报告

上机实习报告班号：116112姓名：**学号：***********实习报告【实习一】线性表及其应用n（n>20）的阶乘【问题描述】大数运算——计算n的阶乘（n>=20）。

【基本要求】（1）数据的表示和存储:（1.1）累积运算的中间结果和最终的计算结果的数据类型要求是整型——这是问题本身的要求；（1.2）试设计合适的存储结构，要求每个元素或结点最多存储数据的3位数值。

（2）数据的操作及其实现：基于设计的存储结构实现乘法操作，要求从键盘上输入n值，在屏幕上显示最终计算结果。

【问题分析】（1）设计数据的存储结构：介于乘运算的精确性以及实型数据表示的不精确性，本题不能采用实型表示累积运算的中间结果和最终的计算结果，而只能用整型。

然而由于普通整型和长整型所能表述数的范围受其字长的限制，不能表示大数阶乘的累积结果，故必须设计一个合适的数据结构实现对数据的存储，例如可以让每个元素或结点存储数据的若干位数值。

从问题描述不难看出n值为任意值，故为使程序尽量不受限制，应采用动态存储结构。

累积运算的特点是当前的计算结果是下次乘法运算的乘数。

实现两个数的乘法运算须考虑：（1）乘数的各位数都要与被乘数进行乘法运算；（2）乘法过程中的进位问题及其实现；（3）因每个元素或结点最多存储数据的3位数值，故当元素或结点中的数值大于999，需向前一个元素或结点进位。

综合以上几点，我采用了单链表的储存结构形式。

（2）阶乘算法的实现：1. 链表型数据乘法的具体实现描述：（1）初始算法顺序访问对每个节点上的数据乘以要乘的数后在顺序访问查看是否需要进位，大于999则向前进位，如果前面没有节点则添加新节点储存进位的数（2）改进算法将原始算法的乘操作和进位操作合在一起进行，提高程序效率.2. 数据输出算法具体实现描述从高位向低位顺序输出节点上储存的数据，注意补零，最高位的节点不补，其它节点要补。

对于最后的结果，因为我采用的是普通的单链表算法，因此我添加了一个逆置的算法。

数据结构集中上机过桥问题详细实验报告

数据结构项目集中上机实践报告姓名：学号：班级：学院：计算机科学与技术专业：计算机科学与技术指导老师：1．实验题目三件有制约关系物品过河问题（80分）有一人要将自己的兔子、蔬菜和狐狸等三件物品运过河。

但过河所用的船每次只能装其中的两件，而这三件物品之间又存在一定的制约关系：兔子不能单独和狐狸以及不能和蔬菜在一起，因为狐狸要吃兔子，兔子也能吃蔬菜。

试构造出问题模型，并编程实现这一问题的求解。

2.数据结构及其存储结构(1)选择对应的数据结构，用图来解决。

(2)选择存储结构，由于问题的规模很小，且总的状态种类很少，所以，我选择邻接矩阵作为图的存储结构。

3.算法的基本思想及分析对象：农夫farmer,狐狸fox,兔子rabbit,蔬菜vegetable。

兔子不能单独和狐狸以及不能和蔬菜在一起，因为狐狸要吃兔子，兔子也能吃蔬菜，如图：农夫兔子狐狸蔬菜算法的思想其实很简单，首先在创建结点，利用is_safe()函数将不安全的结点全部排除，再利用is_connected（）函数得到每个结点的后继结点。

之后利用深度优先搜索可以找到实现这一问题的路径。

问题的分析：①每一个物体都只有两个状态，在原岸或者在对岸；②不同的状态,如农夫和羊在对岸,狼和白菜在原岸；③从一个状态安全地转到另外几个状态，如农夫自己过河或农夫带着羊过河；④不安全状态，如农夫在对岸,其他东西在原岸；⑤初始状态(都在原岸)，结束状态集(都在对岸)。

建立模型：首先，采用二进制中的0/1表示每一个物体的两种状态，用一个四位的二进制数表示一种整体的状态，这样就使原来的问题变的更加易于理解，有利于我们找到合适的数据结构类型来实现问题。

根据对象的状态分为过河（1）和不过河（0），此对象集合就构成了一个状态空间。

问题关键是在这个状态空间内寻找一条从开始状态到结束状态都安全的路径。

其初始状态为四个对象都不过河（都为0），结束状态为四对象全部过河（都是1）。

从一个状态到另一个状态，这其中可以根据相互之间的制约关系，排除不安全的状态，得到安全的路径。

《数据结构》上机实验报告—常用排序算法的实现

return OK;
}
int InsertSort(Form &F)
{//对顺序表F作直接插入排序
int i,j;
int comp=0;//比较次数
int move=0;//移动次数
for(i=2;i<=F.length;i++)
{
comp++;
if(F.r[i].key<F.r[i-1].key)
{
high--;
move++;
}
F.r[low]=F.r[high];
if(low<high&&F.r[low].key<=p)
{
low++;
move++;
}
F.r[high]=F.r[low];
}
F.r[low]=F.r[0];
return low;
}
void main()
{
Form F;
Init_Form(F);
{
F.r[0]=F.r[i]; //F.r[0]是监视哨
F.r[i]=F.r[i-1];
j=i-2;
comp++;
if(F.r[0].key<F.r[j].key)
{//进行元素移动，以腾出位置插入F.r[i]
F.r[j+1]=F.r[j];// 记录后移
j--;
move++;
}
F.r[j+1]=F.r[0]; //在j+1处插入F.r[i]
2.实现快速排序算法。
3.实现折半插入排序。
4.采用几组不同数据测试各个排序算法的性能（比较次数和移动次数）。

数据结构上机报告1

实验1（线性表）：任意输入一串字符，将该字符串看成一个线性表，以链式存储结构(或者静态链表)实现这个线性表，并进行线性表的查找、插入、删除和就地逆置等操作1.需求分析意输入一串字符，将该字符串看成一个线性表，以链式存储结构(或者静态链表)实现这个线性表，并进行线性表的查找、插入、删除和就地逆置等操作2.详细设计1.主函数{输入字符串；生成线性表；调用函数，实现操作；}2.调用函数{ 查找函数；插入函数；删除函数；逆置函数；}3.调用关系图为：void main(){ list_search(); list_insert;list_delete; list_turn()}ADT List{数据对象：D={a i|a i=ElemSet,i=1,2,……,n,n≧0}数据关系：R1={<a i-1,a i>| a i-1,a i€D, i=1,2,……,n }基本操作：list_search (&l); //查找函数list_insert (&l); //插入函数list_delete (&l) ; //删除函数list_turn (&l) //就地逆置}3.用户使用说明先输入一个字符串，回车键结束，程序会自动生成一个线性链表；接着会出现操作选择界面，输入所要进行的操作：输入1进行查找操作，输入要查找元素就会输出元素位置；程序如下：#include<stdio.h>#include<stdlib.h>#include<string.h>struct node{ char data;struct node* prior;struct node* next;};void list_search(struct node* head);void list_insert(struct node* head,int lenth);void list_delete(struct node* head,int lenth);void list_turn(struct node *head);//主函数void main(){struct node head;head.data=0;head.next=NULL;head.prior=NULL;struct node* p=&head;struct node* q=&head;int i=0;char c;printf("请输入字符串:\t");scanf("%c",&c);while(c!='\n'){i++;q=(struct node*)malloc(sizeof(struct node));q->prior=p;q->next=NULL;q->data=c;p->next=q;p=q;scanf("%c",&c);}fflush(stdin);int number=i;p=&head;printf("生成的线性表为:\n");while(p->next){p=p->next;printf("%c",p->data);}int flag=1;char choose;char judge[4];while(flag){printf("\n");printf("请输入你想进行的操作:\n");printf("1---查找\t");printf("2---插入\t");printf("3---删除\t");printf("4---就地逆置\n");int flag1=1;while(flag1){scanf("%c",&choose);fflush(stdin);if(choose=='1'){list_search(&head);flag1=0;} if(choose=='2'){list_insert(&head,number);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}if(choose=='3'){list_delete(&head,number);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}if(choose=='4'){list_turn(&head);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}}int i=number;fflush(stdin);printf("\n继续请输入yes,退出请输入no\n");gets(judge);if(strcmp(judge,"yes")) flag=0;if(strcmp(judge,"no"));}//whileprintf("谢谢使用~\n");}//main//查找函数void list_search(struct node* head){char temp;printf("请输入你要查找的元素:\n");fflush(stdin);scanf("%c",&temp);struct node* p=head;struct node* q=head;int i=0;int flag=1;while(p->next){p=p->next;i++;if(p->data==temp){printf("所查元素的位置是:\t");printf("%d\n",i);flag=0;printf("\n");}}if(flag) printf("所查元素不在线性表内!\n"); }//list_search//插入函数void list_insert(struct node* head,int number){char temp;int pos;printf("请输入你要插入的元素:\n");fflush(stdin);scanf("%c",&temp);int flag=1;while(flag){printf("请输入所插入元素的位置\n");fflush(stdin);scanf("%d",&pos);if(pos>=number||pos<=0) {printf("输入错误,请重新输入!\n");continue;} else flag=0;}struct node* p=head;struct node* q=head;int i=0;while(i<pos-1){p=p->next;i++;}q=(struct node*)malloc(sizeof(struct node));q->data=temp;p->next->prior=q;q->next=p->next;q->prior=p;p->next=q;}//list_insert//删除函数void list_delete(struct node* head,int number){int temp;int flag=1;while(flag){printf("请输入所要删除元素的位置:\n");fflush(stdin);scanf("%d",&temp);if(temp>=number||temp<=0) {printf("输入错误,请重新输入!\n");continue;} else flag=0;}struct node* p=head;struct node* q=head;while(temp){p=p->next;temp--;}q=p->prior;q->next=p->next;if(p->next)p->next->prior=q;free(p);}//list_delete//逆置函数void list_turn(struct node *head) {struct node* p=head;struct node* q=head;struct node* r=q->next;while(r){p=r;r=r->next;q=p->prior;p->prior=p->next;p->next=q;}p->prior=head;head->next->next=NULL;head->next=p;p=head;}//list_inverse set调试结果：。

数据结构上机实验报告

数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称：实验一——链表二﹑实验目的：1.了解线性表的逻辑结构特性；2.熟悉链表的基本运算在顺序存储结构上的实现，熟练掌握链式存储结构的描述方法；3.掌握链表的基本操作（建表、插入、删除等）4. 掌握循环链表的概念，加深对链表的本质的理解。

5.掌握运用上机调试链表的基本方法三﹑实验内容：（1）创建一个链表（2）在链表中插入元素（3）在链表中删除一个元素（4）销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。

void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数，数据由键盘随机输入。

LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表："<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。

数据结构上机实验报告6

三、实验内容
队列的实现（要求有出队和入队函数）
①创建最大长度为10的循环顺序队列。②将a、b、c、d、e、f依次入队，边入队，直到入队完毕。③若队列不空，将元素边出队，边打印输出。④再依次将g、h、i、j、j入队；出队和入队操作时要求输出当前队列的对头和队尾位置。
四、算法描述及实验步骤
用算法表示方法，流程图等形式表达算法设计思想与算法实现步骤
五、调试过程及实验结果
详细记录程序在调试过程中出现的问题及解决方法。
记录程序执行的结果。
六、总结
对上机实践结果进行分析，上机的心得体会。
七、附录（源程序清单）
数据结构上机实验报告6—AAXXX
课程名称：数据结构
年级：
实验日期：
姓名：xxx
学号：AA
班级：
实验名称：队列ቤተ መጻሕፍቲ ባይዱ操作
实验序号：实验六
成员人数：
一、实验目的及要求
1.了解C语言程序的特点
2．掌握简单的C语言程序结构
3．熟练掌握运行Ｃ程序的步骤和方法
4.掌握队列的概念和应用
二、实验环境
Turbo 2.0或相近的环境

《数据结构》上机实验报告—约瑟夫环问题

福州大学数计学院
《数据结构》上机实验报告
专业和班级：信息计算科学与应用数学6班
学号
姓名
成绩
实验名称
线性表结构及其应用
实验内容
约瑟夫环问题
实
验
目
的
和
要
求
【实验目的】
利用单向循环链表解决约瑟夫环问题，提高综合设计能力。
【基本要求】
利用单向循环链表存储结构模拟此过程,按归口炪列的顺序印出各人的编号.
问
题
描
i=1；
while（i<=n)
｛
printf（”请输入第％d个人的密码：”，i);
scanf（"％d",&pwd)；
if(pwd〈= 0)continue；
Insert(L，pwd, i）；
i++;
｝
i = 1；
p = L-〉next；
while（L->next！= L）
｛
q = p;
p = p->next;
【结果截图】
研
究
与
探
讨
解决约瑟夫环问题有三个算法：
一个是在顺序表上实现，另一个是在单向循环链表上实现，第三个则是利用循环队列的方式来实现。
说明：实验名称为教学大纲中各章的实验项目名称,实验内容为具体章节的实验内容名称
述
和
主
要
步
骤
【问题描述】
约瑟夫问题：编号为1，2，。。n的n个人按顺时针方向围坐一圈，每人持有一个密码(正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列,将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止.试设计一个程序求出出列顺序.

数据结构上机实验报告

实验名称：数据结构实验实验时间：2021年X月X日实验地点：计算机实验室实验目的：1. 理解并掌握基本数据结构（线性表、栈、队列、链表、树、图）的概念和操作。

2. 能够运用C语言实现基本数据结构的各种操作。

3. 培养编程能力和问题解决能力。

实验内容：1. 线性表2. 栈3. 队列4. 链表5. 树6. 图实验环境：1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019实验步骤：一、线性表1. 实现线性表的创建、插入、删除、查找和遍历等基本操作。

2. 编写代码，实现以下功能：- 创建一个线性表，包含10个元素。

- 在第3个位置插入一个新元素。

- 删除第5个位置的元素。

- 查找线性表中的第7个元素。

- 遍历线性表，并打印所有元素。

二、栈1. 实现栈的创建、入栈、出栈、判空和求栈顶元素等基本操作。

2. 编写代码，实现以下功能：- 创建一个栈。

- 向栈中依次入栈元素1、2、3、4、5。

- 判断栈是否为空。

- 求栈顶元素。

- 出栈元素，并打印出栈的元素。

三、队列1. 实现队列的创建、入队、出队、判空和求队头元素等基本操作。

2. 编写代码，实现以下功能：- 创建一个队列。

- 向队列中依次入队元素1、2、3、4、5。

- 判断队列是否为空。

- 求队头元素。

- 出队元素，并打印出队的元素。

四、链表1. 实现单链表、双向链表和循环链表的创建、插入、删除、查找和遍历等基本操作。

2. 编写代码，实现以下功能：- 创建一个单链表，包含元素1、2、3、4、5。

- 在第2个位置插入一个新元素。

- 删除第3个位置的元素。

- 查找链表中的第4个元素。

- 遍历链表，并打印所有元素。

五、树1. 实现二叉树的创建、插入、删除、查找和遍历等基本操作。

2. 编写代码，实现以下功能：- 创建一个二叉树，包含元素1、2、3、4、5。

- 在第2个位置插入一个新元素。

- 删除第3个位置的元素。

数据结构上机实验报告

数据结构上机实验报告一、实验目的本次数据结构上机实验的主要目的是通过实际编程操作，深入理解和掌握常见的数据结构及其基本操作，提高解决实际问题的能力和编程技能。

具体目标包括：1、熟练掌握线性表、栈、队列、树、图等数据结构的基本概念和存储方式。

2、学会运用数据结构的相关算法进行数据的插入、删除、查找、排序等操作。

3、培养分析问题、设计算法、编写代码和调试程序的综合能力。

4、增强对数据结构在实际应用中的认识，提高解决复杂问题的思维能力。

二、实验环境1、操作系统：Windows 102、编程环境：Visual Studio 20193、编程语言：C+＋三、实验内容本次实验共包括以下几个部分：1、线性表的操作实现顺序表和链表的创建、插入、删除、查找和遍历操作。

比较顺序表和链表在不同操作下的性能差异。

2、栈和队列的应用利用栈实现表达式求值。

用队列模拟银行排队系统。

3、树的遍历实现二叉树的先序、中序和后序遍历算法，并输出遍历结果。

构建哈夫曼树，并进行编码和解码操作。

4、图的基本操作用邻接矩阵和邻接表存储图，并实现图的深度优先搜索和广度优先搜索算法。

四、实验步骤及结果1、线性表的操作顺序表的实现：｀｀｀cppinclude ＜iostream>using namespace std;define MAXSIZE 100 ／／顺序表的最大长度class SeqList ｛private:int dataMAXSIZE; ／／存储顺序表元素的数组int length; ／／顺序表的当前长度public:SeqList(）｛／／构造函数，初始化顺序表length ＝ 0;｝／／插入元素bool insert(int pos, int element) ｛if （pos ＜ 0 ｜｜ pos ＞ length ｜｜ length ＝＝ MAXSIZE) ｛return false;｝for （int i ＝ length; i ＞ pos; i) ｛datai ＝ datai 1;｝datapos ＝ element;length+＋；return true;｝／／删除元素bool remove(int pos) ｛if （pos ＜ 0 ｜｜ pos ＞＝ length) ｛return false;｝for （int i ＝ pos; i ＜ length 1; i+＋）｛datai ＝ datai ＋ 1;｝length;return true;｝／／查找元素int search(int element) ｛for （int i ＝ 0; i ＜ length; i+＋）｛if （datai ＝＝ element) ｛return i;｝｝return －1;｝／／遍历输出顺序表void traverse(）｛for （int i ＝ 0; i ＜ length; i+＋）｛cout ＜＜ datai ＜＜＂＂；｝cout ＜＜ endl;｝｝；int main(）｛SeqList list;listinsert(0, 10)；listinsert(1, 20)；listinsert(2, 30)；listtraverse(）；listremove(1)；listtraverse(）；int position ＝ listsearch(30)；if （position!＝－1) ｛cout ＜＜＂元素 30 在位置＂＜＜ position ＜＜ endl;｝ else ｛cout ＜＜＂未找到元素 30" ＜＜ endl;｝return 0;｝｀｀｀链表的实现：｀｀｀cppinclude ＜iostream>using namespace std;class Node ｛public:int data;Node next;Node(int element) ｛data ＝ element;next ＝ NULL;｝｝；class LinkedList ｛private:Node head;public:LinkedList(）｛head ＝ NULL;｝／／插入元素void insert(int element) ｛Node newNode ＝ new Node(element)；if （head ＝＝ NULL) ｛head ＝ newNode;｝ else ｛Node current ＝ head;while （current>next!＝ NULL) ｛current ＝ current>next;｝current>next ＝ newNode;｝｝／／删除元素void remove(int element) ｛if （head ＝＝ NULL) ｛return;｝if （head>data ＝＝ element) ｛Node temp ＝ head;head ＝ head>next;delete temp;return;｝Node current ＝ head;Node prev ＝ NULL;while （current!＝ NULL ＆＆ current>data!＝ element) ｛prev ＝ current;current ＝ current>next;｝if （current!＝ NULL) ｛prev>next ＝ current>next;delete current;｝｝／／查找元素bool search(int element) ｛Node current ＝ head;while （current!＝ NULL) ｛if （current>data ＝＝ element) ｛return true;｝current ＝ current>next;｝return false;｝／／遍历输出链表void traverse(）｛Node current ＝ head;while （current!＝ NULL) ｛cout ＜＜ current>data ＜＜＂＂；current ＝ current>next;｝cout ＜＜ endl;｝｝；int main(）｛LinkedList list;listinsert(10)；listinsert(20)；listinsert(30)；listtraverse(）；listremove(20)；listtraverse(）；if （listsearch(30)）｛cout ＜＜＂找到元素 30" ＜＜ endl;｝ else ｛cout ＜＜＂未找到元素 30" ＜＜ endl;｝return 0;｝｀｀｀性能比较：在插入和删除操作中，顺序表在表头或中间位置操作时需要移动大量元素，时间复杂度较高；而链表只需要修改指针，时间复杂度较低。

《数据结构》上机实验报告—利用栈实现迷宫求解

《数据结构》上机实验报告—利用栈实现迷宫求解实验目的：掌握栈的基本操作和迷宫求解的算法，并能够利用栈实现迷宫求解。

实验原理：迷宫求解是一个常见的路径问题，其中最常见的方法之一是采用栈来实现。

栈是一种先进后出的数据结构，适用于这种类型的问题。

实验步骤：1.创建一个迷宫对象，并初始化迷宫地图。

2.创建一个栈对象，用于存储待探索的路径。

3.将起点入栈。

4.循环执行以下步骤，直到找到一个通向终点的路径或栈为空：a)将栈顶元素出栈，并标记为已访问。

b)检查当前位置是否为终点，若是则路径已找到，结束。

c)检查当前位置的上、下、左、右四个方向的相邻位置，若未访问过且可以通行，则将其入栈。

5.若栈为空，则迷宫中不存在通向终点的路径。

实验结果：经过多次实验，发现利用栈实现迷宫求解的算法能够较快地找到一条通向终点的路径。

在实验中，迷宫的地图可通过一个二维数组表示，其中0表示可通行的路径，1表示墙壁。

实验结果显示，该算法能够正确地找出所有可行的路径，并找到最短路径。

实验结果还显示，该算法对于大型迷宫来说，解决速度相对较慢。

实验总结：通过本次实验，我掌握了利用栈实现迷宫求解的算法。

栈作为一种先进后出的数据结构，非常适合解决一些路径的问题。

通过实现迷宫求解算法，我深入了解了栈的基本操作，并学会运用栈来解决实际问题。

此外，我还了解到迷宫求解是一个复杂度较高的问题，对于大型迷宫来说，解决时间较长。

因此，在实际应用中需要权衡算法的速度和性能。

在今后的学习中，我将进一步加深对栈的理解，并掌握其他数据结构和算法。

我还将学习更多的路径算法，以便更好地解决迷宫类问题。

掌握这些知识将有助于我解决更加复杂的问题，并提升编程能力。

数据结构上机实验报告

数据结构上机实验报告1. 实验目的本次实验旨在通过编写程序，掌握和理解常见的数据结构及其应用。

2. 实验环境与工具- 操作系统：Windows 10- 开发语言：C++- 集成开发环境（IDE）：Visual Studio Code3. 实验内容及步骤3.1 线性表操作演示程序设计与分析步骤：a) 设计一个线性表类，并包含以下基本功能：i) 初始化线性表；ii) 插入元素到指定位置；iii) 删除指定位置的元素；iv) 获取指定位置处的元素值。

b）使用该线性表类进行一系列测试，验证各个功能是否正常运行。

记录并分析每个函数调用所消耗时间以评估算法效率。

3.2 栈和队列综合应用设计与模拟步骤:a）根据给出问题需求，在已有栈、队列等相关代码基础上完成如下任务：i）利用两个堆栈来模拟浏览器前进后退功能;ii）使用循环链式存储结构表示双向链队, 并对其进行初始化、入队、出队等操作。

b). 运行以上代码片段，并输出相应结果。

同时分析算法的时间复杂度和空间复杂度。

4. 实验结果与讨论a) 线性表操作演示程序设计与分析实验结果：- 初始化线性表所需时间为X秒；- 插入元素到指定位置平均耗时Y毫秒；- 删除指定位置的元素平均耗时Z毫秒。

b）栈和队列综合应用设计与模拟实验结果：i) 浏览器前进后退功能测试：共浏览N个网页，前进M 次、后退K次。

运行总体消耗时间T1;ii) 双向链队初始化、入队、出对等操作测试: 共进行P 组数据处理, 运行总体消耗时间T2.5. 结论通过本次上机实验，我们掌握了线性表及其相关基本操作，并且成功完成了栈和队列在特定场景下的应用。

同时，在代码编写过程中也深刻理解并评估了各种算法效率。

6. 致谢感谢老师们给予我宝贵意见以及同学们之间相互交流合作提供支持。

7. 附件8. 法律名词及注释在此处添加涉及到的法律名词或术语，并提供简要注释。

数据结构第一次上机实验报告

数据结构第一次上机实验报告（线性表）实验要求：1、实现顺序表结构的创建、插入、删除、查找等操作；2、利用上述顺序表操作实现如下程序：建立两个顺序表表示的集合（集合中无重复的元素），并求这样的两个集合的并、交和源程序：//C++实现//visual studi o 2010下编译通过#include<iostream>#include<vector>#include<algorithm>using namespace std;const size_t MaxSize=20;//顺序表初始分配量class SqList//顺序表类{//privata:int data[MaxSize];int length;//顺序表长度public:void InitList();//初始化void CreatList(int a[],int n);//创建void SearhList();//查找void InsertList();//插入void DeleteList(); //删除};//初始化线性表void SqList::InitList(){length=0;}//创建线性表void SqList::CreatList(int a[],int n){ cout<<"创建的顺序表：\n";for(int i=0;i<n;++i){data[i]=a[i];cout<<data[i]<<" ";}cout<<endl;length=n;}//顺序表的查找void SqList::SearhList(){int k=0;int number;//要查找的数据if(length==0)cout<<"空表"<<endl;else{cout<<"输入要查找的数据:"<<endl;cin>>number;for(int i=0;i<length;++i){if(data[i]==number){k=1;cout<<"查找成功，下标为:"<<i<<endl;break;}//if}//for}//el se}//顺序表的插入void SqList::InsertList(){int i,number;cout<<"请输入要插入的数据："<<endl;cin>>number;cout<<"输入插入的位置："<<endl;cin>>i;while(i<1||i>length){cout<<"越界，请重新输入插入位置："<<endl;cin>>i;}i=i-1;for(int j=length+1;j>i;--j)data[j]=data[j-1];//插入位置后面的元素后移一位data[i]=number;//插入元素length=length+1;//表长加1cout<<"插入元素的线性表：\n";for(int k=0;k<length;++k)cout<<data[k]<<" ";cout<<endl;}//顺序表的删除void SqList::DeleteList(){int i;cout<<"输入要删除的位置:"<<endl;cin>>i;while(i<1||i>length){cout<<"越界，请重新输入要删除的位置："<<endl;cin>>i;}i=i-1;for(int j=i;j<length-1;++j)data[j]=data[j+1];length=length-1;cout<<"删¦除后的顺序表：\n";for(int k=0;k<length;++k)cout<<data[k]<<" ";cout<<endl;}int main(){SqList L;L.InitList();//初始化int a[10];cout<<"向线性表输入数据(10个各不相等Ì的整数)："<<endl;for(int m=0;m<10;++m)cin>>a[m];L.CreatList(a,10);L.SearhList();L.InsertList();L.DeleteList();cout<<"线性表集合操作"<<endl;vector<int> ivec1;vector<int> ivec2;cout<<"向线性表输入数据(10个各不相等的整数)："<<endl;//以矢量容器的形式存储线性表for(int n=0;n<10;++n){while(cin>>a[n]){ivec1.push_back(a[n]);break;}}cin.clear();cout<<"向线性表输入数据(10个各不相等的整数)："<<endl;for(int n=0;n<10;++n){while(cin>>a[n]){ivec2.push_back(a[n]);break;}}//对线性表进行排序sort(ivec1.begin(),ivec1.end());sort(ivec2.begin(),ivec2.end());cout<<"线性表1排序后："<<endl;for(vector<int>::iterator iter1=ivec1.begin();iter1!=ivec1.end();++iter1) cout<<*iter1<<" ";cout<<endl;cout<<"线性表2排序后¨："<<endl;for(vector<int>::iterator iter2=ivec2.begin();iter2!=ivec2.end();++iter2) cout<<*iter2<<" ";cout<<endl;//两线性表的交void AND(vector<int> &ivec1,vector<int> &ivec2);{vector<int> ivec;for(vector<int>::iterator it1=ivec1.begi n();it1!=ivec1.end();++it1){for(vector<int>::iterator it2=ivec2.begi n();it2!=ivec2.end();++it2){if(*it1==*it2)ivec.push_back(*it1);}}cout<<"两线性表的交："<<endl;if(ivec.empty()) cout<<"为空";else{for(vector<int>::iterator it=ivec.begin();it!=ivec.end();++it)cout<<*it<<" ";}cout<<endl;}//两线性表的并void OR(vector<int> &ivec1,vector<int> &ivec2);{vector<int> ivec;for(vector<int>::iterator it1=ivec1.begi n();it1!=ivec1.end();++it1)ivec.push_back(*it1);for(vector<int>::iterator it2=ivec2.begin();it2!=ivec2.end();++it2)ivec.push_back(*it2);sort(ivec.begin(),ivec.end());vector<int>::iterator end_unique=unique(ivec.begin(),ivec.end());//uni que函数将相同数据中的一个放入最后ivec.erase(end_unique,ivec.end());//erase删除unique函数返回位置到表最后的所有元素cout<<"两线性表的并："<<endl;for(vector<int>::iterator it=ivec.begin();it!=ivec.end();++it)cout<<*it<<" ";cout<<endl;}//两线性表的差void cha(vector<int> &ivec1,vector<int> &ivec2);{vector<int>::iterator iter1;vector<int>::iterator iter2;int flag = 0;cout<<"线性表1对线性表2的差："<<endl;for(iter1=ivec1.begin();iter1!=ivec1.end();++iter1){flag = 0;for(iter2=ivec2.begin();iter2!=ivec2.end();++iter2){if((*iter1)==(*iter2)){flag = 1;}}if(flag==0){cout << *iter1 << " ";}}if(flag==1)cout << "为空" << endl;else cout << endl;}}结果：。