数据结构二维数组实验报告
实验六 数组——二维数组与字符串
淮海工学院计算机科学系实验报告书课程名：《 C语言程序设计教程》题目：实验六数组——二维数组与字符串班级：学号：姓名：1、实验内容或题目（1）编写一个程序，计算一个3×4阶矩阵和一个4×3阶矩阵相乘，并打印出结果。
（使用两个二维数组a和b存储两个3×4阶矩阵的元素值，然后用三重for循环进行相乘求值产生二维数组c，最后输出c的各元素值。
）（2）已知某班10个学生的姓名、学号，以及英语、程序设计、数学三门课的成绩，编写一个程序，完成下列工作：·全班每个学生姓名、学号和三门课成绩的输入及总分计算。
·统计各科的总成绩。
·当给出学生姓名或学号时，检索出该生每门功课的成绩及总成绩。
【解】定义一维数组no存储学生学号，二维数组name存储学生姓名，二维数组degree存储学生三门课成绩及总分。
（3）编写一个程序，判定一个字符串是否是另一个字符串的子串。
2、实验目的与要求1、目的：（1）进一步学习程序设计的方法和步骤；（2）掌握循环结构程序设计与数组的结合；3、实验步骤与源程序⑴实验步骤1.建立工程，添加C++源文件，编写程序。
2.调试修改语法错误。
3.编译，链接生成可执行程序。
4.运行程序，检查试验结果。
⑵源代码（一）#include<stdio.h>void main(){int a[3][4]={{2,3},{4,2},{1,2,3}};int b[4][3]={{1,2,3},{2,3,4},{3,4,5}};int c[3][3],i,j,k,s;for(i=0;i<3;i++)for(j=0;j<3;j++){s=0;for(k=s=0;k<4;k++)s+=a[i][k]*b[k][j];c[i][j]=s;}for(j=0;j<3;j++)printf("%4d",c[i][j]);printf("\n");}（二）法一.#include<stdio.h>#include<string.h>const int RS=3;char name[RS][8];int no[RS];float degree[RS][40];void input(){printf("输入数据:");for(int i=1;i<=RS;i++){printf("第%d个学生\n",i);printf("姓名:");scanf("%s",&name[i-1]);printf("学号");scanf("%d",&no[i-1]);printf("英语成绩:");scanf("%f",°ree[i-1][0]);printf("程序设计成绩:");scanf("%f",°ree[i-1][1]);printf("数学成绩:");scanf("%f",°ree[i-1][2]);degree[i-1][3]=degree[i-1][0]+degree[i-1][1]+degree[i-1][2];}}void sum(){float s1=0,s2=0,s3=0;printf("统计各科总成绩\n");for (int i=0;i<RS;i++){s1+=degree[i][0];s2+=degree[i][1];s3+=degree[i][2];}printf("英语总成绩:%g\n",s1);printf("程序设计总成绩:%g\n",s2);printf("数学总成绩:%g\n",s3);}void query(){int sel,bh,i;char xm[8];printf("数据查询\n");printf("1.姓名 2.学号请选择:");scanf("%d",&sel);switch(sel){case 1:printf("输入姓名:");scanf("%s",&xm);for(i=0;i<RS;i++)if(strcmp(xm,name[i])==0){printf("姓名:%s\n",xm);printf("学号:%d\n",no[i]);printf("英语成绩:%g\n",degree[i][0]);printf("程序设计成绩:%g\n",degree[i][1]);printf("数学成绩:%g\n",degree[i][2]);printf("总成绩:%g\n",degree[i][3]);}break;case 2:printf("输入学号:");scanf("%d",&bh);for(i=0;i<RS;i++)if(bh==no[i]){printf("姓名:%s\n",xm);printf("学号:%d\n",no[i]);printf("英语成绩:%g\n",degree[i][0]);printf("程序设计成绩:%g\n",degree[i][1]);printf("数学成绩:%g\n",degree[i][2]);printf("总成绩:%g\n",degree[i][3]);}break;default:printf("无此选项!\n");}}void main(){input();sum();query();}法二.#include<stdio.h>void main(){int score[10],i;float yx=0,lh=0,jg=0,bjg=0,aver=0;int max=0,min=0,maxn,minn;printf("请输入10位学生的成绩:");for(i=0;i<=9;i++){scanf("%d",&score[i]);}for(i=0;i<=9;i++){if(score[i]>max){max=score[i];maxn=i;}if(score[i]<min){min=score[i];minn=i;}aver+=score[i];if(score[i]<60)bjg=bjg+1;else if(score[i]<75)jg=jg+1;else if(score[i]<90)lh=lh+1;else yx=yx+1;}aver/=10;printf("最高分者:%d\n",score[maxn]);printf("最低分者:%d\n",score[minn]);printf("平均分为%.2\n",aver);printf("优秀%.0f人,占比为%.0f%%\n",yx,yx*10);printf("良好%.0f人,占比为%.0f%%\n",lh,lh*10);printf("及格%.0f人,占比为%.0f%%\n",jg,jg*10);printf("不及格%.0f人,占比为%.0f%%\n",bjg,bjg*10); }(三)#include<stdio.h>void main(){int i,j,k,index;char s1[20],s2[20];printf("主字符串:");gets(s1);printf("子字符串:");gets(s2);index=0;for(i=0;s1[i];i++){for(j=i,k=0;s1[j]==s2[k];k++)if(!s2[k+1]){index=i;break;}if(index!=0)break;}printf("位置=%d\n",index);}4、测试数据与实验结果（可以抓图粘贴）5、结果分析与实验体会感觉这次报告比较难，敲代码的时候感觉自己什么都不会了，看到给出的参考都有些崩溃了，前几次还觉得懂了，这次有感觉回到了初学时期，看来以后要多多努力，现在学到的还只是基础，以后学难的要更加下功夫了。
数据结构迷宫实验报告
一、实验目的1. 了解回溯法在求解迷宫问题中的应用。
2. 进一步掌握栈、队列等数据结构在解决实际问题中的应用。
3. 提高编程能力，锻炼逻辑思维能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 迷宫问题概述迷宫问题是指寻找从迷宫入口到出口的路径，且路径上不能有障碍物。
迷宫问题在计算机科学中具有广泛的应用，如路径规划、图论等。
2. 迷宫表示方法迷宫可以用二维数组表示，其中0表示通路，1表示障碍。
例如，以下迷宫可以用以下二维数组表示：```0 1 0 0 10 1 0 1 00 0 0 0 01 1 1 1 00 0 0 0 0```3. 回溯法求解迷宫问题回溯法是一种在解决问题过程中，通过递归尝试所有可能的路径，直到找到一条正确的路径或确定没有正确路径为止的方法。
4. 实验步骤（1）定义迷宫：创建一个二维数组表示迷宫，初始化为通路（0）和障碍（1）。
（2）初始化栈：创建一个栈，用于存储当前路径。
（3）从入口开始，按照上、下、左、右的顺序探索迷宫，每次探索前，将当前位置压入栈中。
（4）判断当前位置是否为出口，如果是，则输出路径并结束程序；如果不是，继续探索。
（5）如果当前位置为障碍或已访问过，则回溯到上一个位置，继续探索其他路径。
（6）重复步骤（3）至（5），直到找到一条从入口到出口的路径或确定没有正确路径为止。
5. 实验结果通过实验，成功实现了使用回溯法求解迷宫问题，并输出了一条从入口到出口的路径。
四、实验分析1. 时间复杂度分析在迷宫中，每个位置最多被访问一次，因此，时间复杂度为O(mn)，其中m和n分别为迷宫的长和宽。
2. 空间复杂度分析实验中使用了栈来存储路径，栈的最大深度为迷宫的宽度，因此，空间复杂度为O(n)。
五、实验总结通过本次实验，我对回溯法在求解迷宫问题中的应用有了更深入的了解，同时也提高了编程能力和逻辑思维能力。
实验报告6-2
实验报告课程名称：高级语言程序设计实验六：一维数组和二维数组班级：学生姓名：学号：专业：指导教师：学期：2015－2016学年上学期云南大学信息学院一、实验目的1、掌握一、二维数组的定义及初始化2、掌握数组元素的输入、输出及引用方法3、掌握使用循环对数组元素进行访问4、掌握一、二维数组的简单应用 二、知识要点1、一、二维数组的定义与赋值（初始化、循环键盘输入）2、访问数组元素（下标的正确使用）3、数组的典型应用（复制、求和、统计某种元素个数、求数组中的最大/最小值、元素的查找与排序）三、实验预习 （要求做实验前完成）1、定义一个有四个元素的float 型数组：float a[4];2、定义一个具有五个元素的整型数组并将其初始化为{1,2,3,4,5}:inta[5]={1,2,3,4,5};3、要用循环从键盘输入整型数组s 的元素值（共6个），应该使用语句：4、交换数组元素d[2]和d[4],使用语句：5、语句for(k=0;k<3;k++) x[2][k] = 0; 将把哪些元素变为0？ 四、实验内容 (要求提供：① 算法描述或流程图 ② 源程序 )1、已知一个数组有10个元素，值分别是3，6，8，4，5，66，80，72，69，70。
编程，将数组元素逆置后输出。
（提示：第一个与最后一个交换位置，第二个与倒数第二个交换位置，……）2、编程序求Fibonacci 数列的前30项，Fibonacci 数列的定义为：⎪⎩⎪⎨⎧>+===--)2()2(1)1(121n f f n n f n n n 要求将数列存放在数组中，并按每行5个数的格式输出该数列。
3、输入14 一个4行4列的二维数组，统计偶数的个数，并输出所有小于5的数。
4、已知一个二维数组：{{14,26,18,17},{24,37,21,8},{19,31,22,16},{7,19,14,26}}，编程，输出该二维数组的最小元素的行下标与列下标。
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，如链表、栈、队列、树和图等，并通过实际编程实现，提高对数据结构的操作和应用能力。
同时，培养解决实际问题的思维和编程能力，提高代码的可读性、可维护性和效率。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用：括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用：排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表：首先定义一个链表节点结构体，包含数据域和指向下一个节点的指针域。
然后通过动态内存分配创建链表节点，并将节点逐个连接起来，形成链表。
插入节点：根据插入位置的不同，分为在表头插入、在表尾插入和在指定位置插入。
在指定位置插入时，需要先找到插入位置的前一个节点，然后进行节点的连接操作。
删除节点：同样需要根据删除位置的不同进行处理。
删除表头节点时，直接将头指针指向下一个节点；删除表尾节点时，找到倒数第二个节点，将其指针置为空；删除指定位置节点时，找到要删除节点的前一个节点，然后调整指针。
遍历链表：通过从链表头开始，依次访问每个节点，输出节点的数据。
2、栈的实现与应用用数组实现栈：定义一个固定大小的数组作为栈的存储空间，同时用一个变量记录栈顶位置。
入栈操作时，先判断栈是否已满，如果未满则将元素放入栈顶位置，并更新栈顶位置；出栈操作时，先判断栈是否为空，如果不空则取出栈顶元素，并更新栈顶位置。
用链表实现栈：与链表的操作类似，将新元素添加在链表头部作为栈顶。
括号匹配：输入一个包含括号的字符串，使用栈来判断括号是否匹配。
遇到左括号入栈，遇到右括号时与栈顶的左括号进行匹配，如果匹配成功则出栈，否则括号不匹配。
数据结构课程实验报告
数据结构课程实验报告一、实验目的数据结构是计算机科学中一门重要的基础课程，通过本次实验，旨在加深对数据结构基本概念和算法的理解，提高编程能力和解决实际问题的能力。
具体目标包括：1、掌握常见数据结构（如数组、链表、栈、队列、树、图等）的基本操作和实现方法。
2、学会运用数据结构解决实际问题，培养算法设计和分析的能力。
3、提高程序设计的规范性和可读性，培养良好的编程习惯。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容本次实验共包括以下几个部分：（一）线性表的实现与操作1、顺序表的实现定义一个顺序表结构体，包含数据元素数组和表的长度。
实现顺序表的初始化、插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体，包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
（二）栈和队列的实现与应用1、栈的实现采用顺序存储或链式存储实现栈。
实现栈的入栈、出栈、栈顶元素获取等操作，并应用于表达式求值。
2、队列的实现用循环队列或链式队列实现队列。
实现队列的入队、出队、队头元素获取等操作，应用于模拟排队系统。
（三）树的基本操作与遍历1、二叉树的实现定义二叉树节点结构体，包含数据域、左子树指针和右子树指针。
实现二叉树的创建、插入、删除节点等操作。
2、二叉树的遍历分别实现前序遍历、中序遍历和后序遍历，并输出遍历结果。
（四）图的表示与遍历1、邻接矩阵和邻接表表示图定义图的结构体，使用邻接矩阵和邻接表两种方式存储图的信息。
实现图的创建、添加边等操作。
2、图的遍历分别用深度优先搜索（DFS）和广度优先搜索（BFS）遍历图，并输出遍历序列。
四、实验步骤（一）线性表的实现与操作1、顺序表的实现首先，定义了一个结构体｀SeqList` 来表示顺序表，其中包含一个整数数组｀data` 用于存储数据元素，以及一个整数｀length` 表示表的当前长度。
在初始化函数｀InitSeqList` 中，将表的长度初始化为 0，并分配一定的存储空间给数组。
数据结构迷宫问题实验报告
《数据结构与算法设计》迷宫问题实验报告——实验二专业：物联网工程班级：物联网1班学号：********姓名：***一、实验目的本程序是利用非递归的方法求出一条走出迷宫的路径，并将路径输出。
首先由用户输入一组二维数组来组成迷宫，确认后程序自动运行，当迷宫有完整路径可以通过时，以0和1所组成的迷宫形式输出，标记所走过的路径结束程序；当迷宫无路径时，提示输入错误结束程序。
二、实验内容用一个m*m长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序对于任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
三、程序设计1、概要设计（1）设定栈的抽象数据类型定义ADT Stack{数据对象：D={ai|ai属于CharSet，i=1、2…n，n>=0}数据关系：R={<ai-1,ai>|ai-1,ai属于D，i=2,3,…n}基本操作：InitStack(&S)操作结果：构造一个空栈Push（&S，e）初始条件：栈已经存在操作结果：将e所指向的数据加入到栈s中Pop（&S,&e）初始条件：栈已经存在操作结果：若栈不为空，用e返回栈顶元素，并删除栈顶元素Getpop（&S，&e）初始条件：栈已经存在操作结果：若栈不为空，用e返回栈顶元StackEmpty(&S)初始条件：栈已经存在操作结果：判断栈是否为空。
若栈为空，返回1，否则返回0Destroy(&S)初始条件：栈已经存在操作结果：销毁栈s}ADT Stack（2）设定迷宫的抽象数据类型定义ADT yanshu{数据对象：D={ai,j|ai,j属于{‘’、‘*’、‘@’、‘#’},0<=i<=M,0<=j<=N}数据关系：R={ROW,COL}ROW={<ai-1,j,ai,j>|ai-1,j,ai,j属于D，i=1,2,…M,j=0,1,…N}COL={<ai,j-1,ai,j>|ai,j-1,ai,j属于D,i=0,1,…M，j=1,2,…N}基本操作：InitMaze(MazeType &maze, int a[][COL], int row, int col){初始条件：二维数组int a[][COL],已经存在，其中第1至第m-1行，每行自第1到第n-1列的元素已经值，并以值0表示障碍，值1表示通路。
实验七 二维数组实验报告
***软件类实验报告课程名称：C语言程序设计学号：姓名：班级：指导教师：开课学期：学院：***教务处⑶二维数组处理矩阵问题。
四、实验过程及内容：（运行结果请抓图到对应题目的下方）1.输入下面的程序，说明程序的功能并分析运行结果。
2.程序填空题。
加法口诀表。
输入1个正整数n(1≤n≤10)，输出一张10以内的加法口诀表。
加数与被加数都不大于n(将加数、被加数、和放入一个二维数组中，再输出该数组)，程序运行结果如图7-1所示。
填空完成程序。
实验结果：3. 程序填空题。
下列程序定义了M×N的二维数组，并在主函数中对其赋值。
函数fun()的功能是计算数组周边元素的平均值并作为函数值返回给主函数。
实验结果：4. 编程insert函数，insert函数的功能是：实现在字符串s的指定的下标位置插入另一个字符串t。
例如：字符串s为“I am a boy.”,t为“good ”，调用insert(s,7,t);则s结果为“I am a good boy.”。
主函数框架如下：#include "stdio.h"#include "string.h"void main(){char s[100]="I am a boy.",t[50]="good ";void insert(char s[],int n,char t[]);insert(s,7,t);puts(s);}请完成insert函数的定义。
实验结果：5. 程序改错题。
打印九九乘法表。
6.编写程序实现，求3*3矩阵两条对角线元素之和五、实验小结。
数组的实验报告结论(3篇)
第1篇一、实验目的本次实验旨在通过一系列的数组操作，验证数组的定义、创建、赋值、遍历、排序、查找等基本操作，掌握数组在实际编程中的应用，提高编程能力。
二、实验内容1. 数组的定义与创建通过定义数组变量，并使用不同的方式创建数组，如使用{}直接创建、使用new创建等，验证了数组的创建方法。
2. 数组的赋值通过给数组元素赋值，观察数组的实际内容，验证了数组的赋值操作。
3. 数组的遍历通过for循环、增强型for循环、foreach循环等不同方式遍历数组，验证了数组的遍历方法。
4. 数组的排序通过冒泡排序、选择排序、插入排序等算法对数组进行排序，验证了数组的排序操作。
5. 数组的查找通过顺序查找、二分查找等算法对数组进行查找，验证了数组的查找操作。
三、实验结果与分析1. 数组的定义与创建实验结果显示，通过定义数组变量，并使用不同的方式创建数组，均能成功创建数组。
在实际编程中，应根据具体需求选择合适的创建方式。
2. 数组的赋值实验结果显示，给数组元素赋值后，数组的内容发生了变化，验证了数组的赋值操作。
3. 数组的遍历实验结果显示，通过不同的遍历方式，均能成功遍历数组。
在实际编程中，应根据具体需求选择合适的遍历方式。
4. 数组的排序实验结果显示，通过冒泡排序、选择排序、插入排序等算法对数组进行排序，均能成功实现数组的排序。
在实际编程中，应根据具体需求选择合适的排序算法。
5. 数组的查找实验结果显示，通过顺序查找、二分查找等算法对数组进行查找，均能成功实现数组的查找。
在实际编程中，应根据具体需求选择合适的查找算法。
四、实验结论1. 数组是实际编程中常用的一种数据结构，具有丰富的操作方法。
2. 掌握数组的定义、创建、赋值、遍历、排序、查找等基本操作，有助于提高编程能力。
3. 在实际编程中，应根据具体需求选择合适的数组创建、遍历、排序、查找等方法，以提高编程效率和代码质量。
4. 本实验为后续学习其他数据结构和算法奠定了基础，有助于提高编程水平。
数组实验报告实验小结
一、实验背景随着计算机技术的不断发展，数组作为一种基本的数据结构，在编程领域得到了广泛的应用。
为了更好地理解和掌握数组的相关知识，我们进行了一系列的数组实验。
本次实验报告将对实验过程进行总结，并对实验结果进行分析。
二、实验目的1. 理解数组的基本概念和特点；2. 掌握数组的创建、访问和操作方法；3. 熟悉数组在编程中的应用；4. 培养实验操作能力和问题解决能力。
三、实验内容1. 数组的定义与创建2. 数组的初始化3. 数组元素的访问与修改4. 数组的排序与查找5. 数组的应用实例四、实验过程1. 数组的定义与创建实验一：定义一个整型数组，并初始化为10个元素。
代码如下：```c#include <stdio.h>int main() {int arr[10];// 初始化数组for (int i = 0; i < 10; i++) {arr[i] = i 2;}// 打印数组元素for (int i = 0; i < 10; i++) {printf("%d ", arr[i]);}printf("\n");return 0;}```2. 数组的初始化实验二：使用初始化列表直接初始化数组。
代码如下：```c#include <stdio.h>int main() {int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 打印数组元素for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) { printf("%d ", arr[i]);}printf("\n");return 0;}```3. 数组元素的访问与修改实验三：访问和修改数组元素。
代码如下：```c#include <stdio.h>int main() {int arr[5] = {1, 2, 3, 4, 5};// 访问数组元素printf("The first element is: %d\n", arr[0]);// 修改数组元素arr[0] = 10;printf("After modification, the first element is: %d\n", arr[0]); return 0;}```4. 数组的排序与查找实验四：使用冒泡排序算法对数组进行排序。
二维数组的实验报告
int main()
{ int a[100],i,n,k;
do
{
printf("输入数组的元素个数:\n");
scanf("%d",&n);
}while(n<0||n>100);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
{
sum+=array[i];
if(max<array[i])
max=array[i];
if(min>array[i])
min=array[i];
}
average=sum*1.0/10;
printf("数组的最大值与最小值，平均值如下\n");
printf("%5f%15f%15f\n",max,min,average);
return 0;
}
实验结果：
2，实验2
#include<stdio.h>
void Print(int array[],int length);
double Average(int array[],int length);
int GetMax(int array[],int length);
int Retrieve(int array[],int length,int x);
2.在main（）中定义一个一维数组，从键盘读入数组元素，定义下列函数并在主函数中对各函数进行调用和测试。各自定义函数原型及功能分别如下：
A.打印函数，输出整个数组，数组名array，数组长度length，无返回值。
数据结构二维数组实验报告
数据结构二维数组实验报告————————————————————————————————作者：————————————————————————————————日期：数据结构（2013）实验报告04班级：XXXX姓名：XXX实验方式：上机成绩：教师批阅处：一、实验名称二维数组基本操作的编程实现二、实验目的二维数组基本操作的编程实现，掌握二维数组的建立、读取数据、压缩存储等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
三、实验内容修改程序补充推箱子游戏的遗缺的部分，使之能正常运行，逻辑结果正确。
之后增加至少一关自己的关数，墙体，箱子的最初位置，人的最初位置由自己设定，要求必须有解，而且有一定的破解难度。
主要的问题是部分移动方向的代码没有给出，另外计数器的整体工作不正常，更完善的修改包括启用栈结构实现后悔的机制。
1、补充左方向和上方向移动根据源程序提供的右方向和下方向移动的原码，只需将原码稍作修改就能完成移动功能了。
很明显上和下、左和右是两两对应的两个方向，所以只需将原码的‘+’、‘-’号相应修改即可。
但是，抵消人不动的情况中的“count--”不能改动。
2、计数器的改正刚开始游戏的时候，计数器的值应该为0，所以用以计数的变量应初始化为0。
当运行程序时，发现计数器的初始值为111。
所以找到计数器变量并将其致值为0。
而且，当修改好四个方向后，向左和上移动时，计数器的值没变化。
这里，要在条用左方向和上方向的下面，添加计数器，使每调用一次（走一步），计数器加1。
3、添加关数在原来的基础上，我添加了第四和第五两关。
地图原码及截图如下：int map4[roomsize+2][roomsize+2]={ //0,1,2,3,4,5,6,7,8,9,10{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//0{-1,0,1,1,1,1,1,1,1,-1,-1}, //1{-1,0,1,0,4,2,2,2,1,-1,-1}, //2{-1,0,1,0,0,0,1,1,1,1,-1}, //3{-1,1,1,1,3,0,0,0,0,1,-1}, //4{-1,1,0,0,0,1,3,1,0,1,-1}, //5{-1,1,0,3,0,1,0,0,0,1,-1}, //6{-1,1,0,0,0,1,1,1,1,1,-1}, //7{-1,1,1,1,1,1,0,0,0,-1,-1}, //8{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//9{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} //10};int map5[roomsize+2][roomsize+2]={ //0,1,2,3,4,5,6,7,8,9,10{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//0{-1,1,1,1,1,1,1,1,1,-1,-1}, //1{-1,1,0,0,0,0,0,0,1,-1,-1}, //2{-1,1,0,0,1,1,1,0,0,1,-1}, //3{-1,1,3,4,3,0,0,3,0,1,-1}, //4{-1,1,2,2,1,1,3,0,0,1,-1}, //5{-1,1,2,2,1,1,0,0,0,1,-1}, //6{-1,1,1,1,1,1,1,1,1,1,-1}, //7{-1,1,1,1,1,1,1,1,1,-1,-1}, //8{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//9{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} //10};第四关：游戏前游戏完成时图 1第五关：游戏前游戏完成时图 24、添加后退功能在本实验中添加的后退功能，只能后退一步。
最新计算机操作系统实验五 二维数组实现银行家...(1)
计算机操作系统实验五二维数组实现银行家 (1)操作系统实验五实验报告内容（用二维数组实现银行家算法）组长：赖建明组员：赖建明（34号）何文成（26号）莫善坤（9号）李居林（13号）黄小龙（23号）高大旺（29号）一、实验题目与要求：1、用二维数组实现银行家算法（避免死锁）。
二、总的设计思想及：1、设计思想：避免分配资源也称作Banker(银行家)算法。
Banker算法的主要思想：若进程Pi的申请超过了其申报的最大需求数，则报错；若进程Pi的申请超过了可用资源数，则Pi必须等待；系统暂时为进程Pi分配其所需要的资源，修改资源分配状态；调用安全算法检查系统当前状态，若导致不安全状态，则推迟这种分配。
三、数据结构与模块说明（功能与框图）：数据结构：安全性算法：（参考课本P102页）Available：向量（一维数组），指出当前每种类型资源可用实例的总数量。
Max：每个进程对每种资源类型实例的最大需求，它是 n x m 矩阵（二维数组）。
Allocation：每个进程当前已分配的各种资源类型的实例数量，它是 n x m 矩阵（二维数组）。
Need：每个进程还需要的剩余的资源，它是 n x m 矩阵（二维数组）need = max – allocation。
向量 Work ：是临时的资源使用数组，它初始化为当前可用的资源数。
向量 Finish：是布尔型数组，每个进程一个单元并初始化为 false。
模块说明：功能：银行家算法主要有两部分：资源请求部分和安全检测部分。
对于资源请求部分，首先检查进程的本次请求是否超过它的最初资源要求总量；如果本资源共享进程请求有效，下一步确定系统是否可以满足进程的这次请求；如果不能满足；挂起进程，如果可以满足，调用安全检测算法。
对于资源请求算法如下情况：1、 如果Allocation[I,*]+Rquest[*]<=Need[I,*],则转（2），否则因进程i 已起出其最大需求，系统出错。
最新《实验二：数组》实验报告
最新《实验二：数组》实验报告实验目的：1. 掌握数组的基本概念和使用方法。
2. 理解数组在内存中的存储方式。
3. 学会使用循环结构对数组进行遍历和操作。
4. 培养解决实际问题时数组应用的能力。
实验环境：- 操作系统：Windows 10- 开发工具：Visual Studio 2019- 编程语言：C++实验内容：1. 创建一个整型数组，包含10个元素，初始化为0到9的整数。
2. 使用循环结构实现数组中所有元素的累加，并输出结果。
3. 编写一个函数，计算数组中所有偶数的和，并返回结果。
4. 实现一个功能，允许用户输入一个整数，将其插入到数组的指定位置。
5. 对数组进行排序，使用冒泡排序算法，并输出排序后的数组。
实验步骤：1. 定义一个整型数组arr[10]，并初始化。
2. 使用for循环，遍历数组，计算累加和，并输出。
3. 定义一个函数int calculateEvenSum(int arr[], int size)，接收数组和数组大小作为参数，计算偶数和。
4. 实现用户输入功能，通过scanf获取用户输入的整数和指定位置，调用一个函数void insertElement(int arr[], int size, int value, int position)进行插入。
5. 应用冒泡排序算法对数组进行排序，定义一个函数voidbubbleSort(int arr[], int size)实现排序，并输出排序后的结果。
实验结果：1. 初始数组：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}。
2. 数组累加和输出：45。
3. 偶数和输出：20。
4. 用户输入插入操作：假设用户输入的值为5，指定位置为3，插入后的数组：{0, 1, 5, 2, 3, 4, 5, 6, 7, 8, 9}。
5. 排序后的数组输出：{0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9}。
实验分析：通过本次实验，我们成功实现了数组的基本操作，包括初始化、遍历、插入、计算和排序。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括：1、熟悉常见的数据结构，如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作，如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力，能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性，实现入栈和出栈操作。
队列的先进先出原则，完成入队和出队功能。
3、树的操作二叉树的创建、遍历（前序、中序、后序）。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表：首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。
通过创建链表头节点，并使用循环依次插入新节点，实现了链表的创建。
插入节点时，根据指定位置找到插入点的前一个节点，然后修改指针完成插入操作。
删除节点时，同样找到要删除节点的前一个节点，修改指针完成删除。
实验结果：成功创建、插入和删除了单向链表的节点，并正确输出了链表的内容。
双向链表：双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果：双向链表的各项操作均正常，能够双向遍历链表。
循环链表：使链表的尾节点指向头节点，形成循环。
在操作时需要特别注意循环的边界条件。
实验结果：成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈：使用数组或链表来实现栈。
入栈操作将元素添加到栈顶，出栈操作取出栈顶元素。
实验结果：能够正确进行入栈和出栈操作，验证了栈的后进先出特性。
数据结构实验报告 图
数据结构实验报告图一、实验目的本次实验的主要目的是深入理解和掌握图这种数据结构的基本概念、存储结构和相关算法，并通过实际编程实现来提高对图的操作和应用能力。
二、实验环境本次实验使用的编程语言为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语言实验报告 实验六 参考答案
实验六二维数值数组（参考答案）(1) 设计程序sy6-1.c，从键盘上输入一个3行3列矩阵各个元素的值，输出其主对角线元素和反向对角线元素之和。
算法分析：方阵主对角线上的元素，行下标和列下标相同；辅对角线元素，如果行下标为i，列下标就为2-i；参考答案：# include <stdio.h># include <stdlib.h># include <math.h># include <time.h>void main(){int a[3][3];int i,j,sum=0;srand( time( NULL ) );printf("矩阵：\n");for(i=0;i<3;i++) //用随机函数生成3行3列的二维数组并按矩阵格式输出{for(j=0;j<3;j++){a[i][j]=rand()%20;printf("%4d",a[i][j]);}printf("\n");}for(i=0;i<3;i++)sum=sum+a[i][i]+a[i][2-i];printf("该矩阵的正、反对角线元素之和为：%d\n",sum);}运行结果：(2) 设计程序sy6-2.c，找出N×N矩阵中每列元素中的最大值，并按顺序依次存放于b数组中。
算法分析：按列序遍历二维数组，每列用打擂台的方法求最大数，N列则有N个最大值，分别存于b数组的对应元素中。
# include <stdio.h># include <stdlib.h># include <math.h># include <time.h># define N 4void main(){int a[N][N],b[N];int i,j;srand( time( NULL ) );printf("矩阵：\n");for(i=0;i<N;i++) //用随机函数生成N行N列的二维数组并按矩阵格式输出{for(j=0;j<N;j++){a[i][j]=rand()%20;printf("%4d",a[i][j]);}printf("\n");}for(j=0;j<N;j++) //外循环控制列下标{b[j]=a[0][j]; //假设每列的0行元素是最大数for(i=1;i<N;i++)if(b[j]<a[i][j])b[j]=a[i][j];}printf("该矩阵每列元素的最大值是：\n");for(i=0;i<N;i++)printf("%4d",b[i]);printf("\n");}运行结果：(3) 设计程序sy6-3.c，定义一个3×3的二维数组，通过随机函数自动赋值。
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，通过实际编程实现和操作，提高对数据结构的应用能力和编程技巧。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容1、线性表的基本操作实现线性表的创建、插入、删除、查找等基本操作。
对不同操作的时间复杂度进行分析和比较。
2、栈和队列的应用利用栈实现表达式求值。
使用队列模拟银行排队系统。
3、二叉树的遍历实现二叉树的先序、中序、后序遍历算法。
分析不同遍历算法的特点和应用场景。
4、图的表示和遍历采用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历算法。
四、实验步骤及结果1、线性表的基本操作首先，定义了一个线性表的结构体，包含数据域和指针域。
创建线性表时，动态分配内存空间，并初始化表头和表尾指针。
插入操作分为表头插入、表尾插入和指定位置插入。
在指定位置插入时，需要先找到插入点的前一个节点，然后进行插入操作。
删除操作同样需要找到要删除节点的前一个节点，然后释放删除节点的内存空间，并调整指针。
查找操作通过遍历线性表，逐个比较数据值来实现。
经过测试，不同操作的时间复杂度如下：创建操作的时间复杂度为 O(1)。
插入操作在表头和表尾插入的时间复杂度为 O(1)，在指定位置插入的时间复杂度为 O(n)。
删除操作的时间复杂度为 O(n)。
查找操作的平均时间复杂度为 O(n)。
2、栈和队列的应用表达式求值：将表达式转换为后缀表达式，然后利用栈进行计算。
遇到操作数则入栈，遇到操作符则从栈中弹出两个操作数进行计算，并将结果入栈。
最后栈顶元素即为表达式的结果。
银行排队系统：使用队列模拟客户的排队过程。
客户到达时入队，服务窗口空闲时从队列头部取出客户进行服务。
实验结果表明，栈和队列能够有效地解决相关问题，提高程序的效率和可读性。
3、二叉树的遍历先序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
大学数据结构实验报告模板
大学数据结构实验报告模板一、实验目的数据结构实验是计算机相关专业课程中的重要实践环节，通过实验可以加深对数据结构理论知识的理解，提高编程能力和解决实际问题的能力。
本次实验的主要目的包括：1、掌握常见数据结构（如数组、链表、栈、队列、树、图等）的基本操作和实现方法。
2、学会运用数据结构解决实际问题，培养算法设计和分析能力。
3、提高程序设计的规范性和代码质量，培养良好的编程习惯。
4、熟悉编程语言（如C、C+＋、Java 等）的开发环境和调试技巧。
二、实验环境1、操作系统：＿____2、编程语言：＿____3、开发工具：＿____三、实验内容（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构。
实现顺序表的初始化、插入、删除、查找等基本操作。
2、链表的实现定义链表的数据结构（单链表、双向链表或循环链表）。
实现链表的创建、遍历、插入、删除等操作。
（二）栈和队列的实现与应用1、栈的实现定义栈的数据结构。
实现栈的入栈、出栈、栈顶元素获取等操作。
利用栈解决括号匹配、表达式求值等问题。
2、队列的实现定义队列的数据结构。
实现队列的入队、出队、队头元素获取等操作。
利用队列实现广度优先搜索、任务调度等应用。
（三）树的实现与遍历1、二叉树的实现定义二叉树的数据结构（二叉链表或顺序存储）。
实现二叉树的创建、前序遍历、中序遍历、后序遍历。
2、二叉搜索树的实现实现二叉搜索树的插入、删除、查找操作。
3、平衡二叉树（如 AVL 树）的实现（选做）理解平衡二叉树的平衡调整算法。
实现平衡二叉树的插入和删除操作，并保持树的平衡。
（四）图的表示与遍历1、图的邻接矩阵和邻接表表示定义图的数据结构（邻接矩阵或邻接表）。
实现图的创建和初始化。
2、图的深度优先遍历和广度优先遍历实现图的深度优先遍历和广度优先遍历算法。
应用图的遍历解决最短路径、连通性等问题。
（五）排序算法的实现与性能比较1、常见排序算法的实现实现冒泡排序、插入排序、选择排序、快速排序、归并排序等算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构二维数组实验报告
————————————————————————————————作者：————————————————————————————————日期：
数据结构（2013）实验报告04
班级：XXXX姓名：XXX实验方式：上机成绩：
教师批阅处：
一、实验名称
二维数组基本操作的编程实现
二、实验目的
二维数组基本操作的编程实现，掌握二维数组的建立、读取数据、压缩存储等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
三、实验内容
修改程序
补充推箱子游戏的遗缺的部分，使之能正常运行，逻辑结果正确。
之后增加至少一关自己的关数，墙体，箱子的最初位置，人的最初位置由自己设定，要求必须有解，而且有一定的破解难度。
主要的问题是部分移动方向的代码没有给出，另外计数器的整体工作不正常，更完善的修改包括启用栈结构实现后悔的机制。
1、补充左方向和上方向移动
根据源程序提供的右方向和下方向移动的原码，只需将原码稍作修改就能完成移动功能了。
很明显上和下、左和右是两两对应的两个方向，所以只需将原码的‘+’、‘-’号相应修改即可。
但是，抵消人不动的情况中的“count--”不能改动。
2、计数器的改正
刚开始游戏的时候，计数器的值应该为0，所以用以计数的变量应初始化为0。
当运行程序时，发现计数器的初始值为111。
所以找到计数器变量并将其致值为0。
而且，当修改好四个方向后，向左和上移动时，计数器的值没变化。
这里，要在条用左方向和上方向的下面，添加计数器，使每调用一次（走一步），计数器加1。
3、添加关数
在原来的基础上，我添加了第四和第五两关。
地图原码及截图如下：
int map4[roomsize+2][roomsize+2]=
{ //0,1,2,3,4,5,6,7,8,9,10
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//0
{-1,0,1,1,1,1,1,1,1,-1,-1}, //1
{-1,0,1,0,4,2,2,2,1,-1,-1}, //2
{-1,0,1,0,0,0,1,1,1,1,-1}, //3
{-1,1,1,1,3,0,0,0,0,1,-1}, //4
{-1,1,0,0,0,1,3,1,0,1,-1}, //5
{-1,1,0,3,0,1,0,0,0,1,-1}, //6
{-1,1,0,0,0,1,1,1,1,1,-1}, //7
{-1,1,1,1,1,1,0,0,0,-1,-1}, //8
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//9
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} //10
};
int map5[roomsize+2][roomsize+2]=
{ //0,1,2,3,4,5,6,7,8,9,10
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//0
{-1,1,1,1,1,1,1,1,1,-1,-1}, //1
{-1,1,0,0,0,0,0,0,1,-1,-1}, //2
{-1,1,0,0,1,1,1,0,0,1,-1}, //3
{-1,1,3,4,3,0,0,3,0,1,-1}, //4
{-1,1,2,2,1,1,3,0,0,1,-1}, //5
{-1,1,2,2,1,1,0,0,0,1,-1}, //6
{-1,1,1,1,1,1,1,1,1,1,-1}, //7
{-1,1,1,1,1,1,1,1,1,-1,-1}, //8
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},//9
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} //10
};
第四关：
游戏前游戏完成时
图 1
第五关：
游戏前游戏完成时
图 2
4、添加后退功能
在本实验中添加的后退功能，只能后退一步。
重新定义一个二维全局数组，用来记录前一步的情况，在back函数中记录上一步的位置，当要后退时，按‘b’完成。
代码如下：
void box::back(int step)
{
int i,j;
switch(step)
{
case 1:
for(i=0;i<roomsize+2;i++)
for(j=0;j<roomsize+2;j++)
newmap[i][j]=map[i][j];
newpositionh=positionh;
newpositionl=positionl;
break;
case 2:
for(i=0;i<roomsize+2;i++)
for(j=0;j<roomsize+2;j++)
map[i][j]=newmap[i][j];
positionh=newpositionh;
positionl=newpositionl;
break;
}
}
5、其他修改
在实验过程中，发现了一些问题，并做了修改。
（1）添加“退出游戏”功能
当运行程序进入主界面时，若要退出，只能先选关进入游戏，再通过‘c’或‘q’选项才能退出。
我认为不好，所以在主界面增加了“退出游戏”选项，以便突然不想玩时，可以正常退出。
图 3
（2）容错的完善
①在选关的时候，不小心按了个大于5的数，重新输入正确数字的时候，进入游戏时没有地图，是空白的，如下：
图 4 空白地图
只需简单的修改：do while循环应从输入关数选项那地方开始，default中的重新输入项“cin>>gate;”删掉即可。
②在游戏过程中，想重玩时，不在意先按了下回车键，再按‘c’和‘q’时，都没有作用，游戏也就没有了出口了。
在按调用‘c’选项之前加上一句“system(“pause”)”即可。
四、实验总结
1、实验的不足
本次实验在添加后退功能上有很大的不足，只能后退一步，并不能后退到最开始的地方。
2、努力方向及感想
通过这次实验，又发现了自己的一些新问题，没能正确使用栈的功能实现强大的后退功能，温顾能知新，学过的知识经常复习，经常用能得到新的收获。
通过这次实验，对游戏有了初步的了解，通过对游戏的修改和完善，也有了新的认识和收获，对二维数组的应用也有了新的认识，第一次发现二维数组还可以这么使用。
3、致谢
感谢XXX同学，在这次实验中为我找错纠错，为我提出宝贵的意见！。