迷宫求解(课程设计)
《数据结构》课程设计说明书
题目
迷宫求解
系部：
学生姓名：
指导教师：
专业：
班级：
完成时间：
利用栈的知识来求出从入口到出口的所有路径。采用穷举算法，即从入口出发，顺某一方向向前探索，若能走通，则继续向前走；否则沿原路退回一步，换一个方向再继续向前探索，直至所有可能的通路都探索到为止。为了保证在任何位置上都能沿原路退回，则需要一个栈来保存路径。迷宫的输入提供了两种形式，一种是系统默认的输入形式，令一种是用户可以指定文件，只要文件符合格式，用户即可将其作为迷宫地图。最终即可以显示总的路径数目，也可用箭头的形式显示迷宫的走法，形象直观。
关键词课程设计；数据结构；非递归；栈；迷宫求解
目录 (3)
一、设计任务书 (4)
二、程序功能简介 (4)
三、主体内容 (4)
1. 设计分析 (4)
2. 程序结构流程图 (5)
3. 各模块的功能及程序说明 (5)
4. 实验结果（截图） (9)
5. 设计体会 (12)
6. 参考文献 (13)
四、附录(程序清单) (13)
一、设计任务书
1.加深对数据结构课程和基本知识的理解；
2.提高运用数据结构解决实际问题的能力；
3.通过本课程设计，使学生为将来进行软件开发打下良好基础
二、程序功能简介
利用栈的知识来求出从入口到出口的所有路径。采用穷举算法，即从入口出发，顺某一方向向前探索，若能走通，则继续向前走；否则沿原路退回一步，换一个方向再继续向前探索，直至所有可能的通路都探索到为止。
三、主体内容
1、设计分析
1.1问题提出
不用递归算法求解迷宫
1.2本系统涉及的知识点
本系统涉及到所学过的知识点有：编译预处理，结构体，函数，栈等
1.3功能要求
可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出
2. 程序结构流程图
3．各模块的功能及程序说明
1、程序中所用到的数据及其数据类型的定义：
typedef struct PositionType{
int row;
int col;
int nextDirection;
//0表示障碍，1表示通路，2表示开始点，3表示结束点，*表示走过的路径，@表示死路，#表示碰到的障碍
char sign;
}PositionType;
该类型为节点类型，程序中定义了一个节点二维数组PositionType pos[MAXNUM][MAXNUM]用来表示迷宫
typedef PositionType SElemType;
typedef struct LNode
{
PositionType data;
struct LNode *next;
}LNode,*LinkStack;
此为栈类型。
2、求迷宫的伪码算法如下：
do{
if(当前位置的sign为'1'||当前位置的sign为'2'){
将当前位置的sign改为'*';
将当前位置放入栈中；
size++；
//更改当前位置为当前位置的下一个节点（节点只能为'0'||'1'）；
findNextPosition();
}
if(当前位置sign为'0'||当前位置sign为'#'){
将当前位置的sign改为'#';
pop(s,e);
当前位置改为出栈位置;
step--;
}
if(当前位置sign为'3'){
将当前位置的sign改为'*';
将当前位置放入栈中；
size++;
break;
}
if(当前位置sign为'*'){
if(当前位置nextDirection==5){
将当前位置的sign改为'@';
出栈；
当前位置改为出栈位置;
size--;
}
if(当前位置nextDirection<5){
//当前位置的下一个位置；(通过函数来来实现，节点只能为'0'||'1'，nextDirection++;和nextDirection的数值有关系;nextDirection++;)
findNextPosition();
}
}
totalSize++;
}while(栈不空);
3、该系统用到的函数如下：
(1) 链栈操作的基本函数如下：
initStack(LinkStack &S)
操作结果：构造一个空栈S。
destroyStack(int stackLength(LinkStack &S)
初始条件：栈S已存在。
操作结果：销毁栈S。
stackLength(LinkStack S)
初始条件：栈S已存在。
操作结果：返回栈S的长度。
clearStack(LinkStack &S)
初始条件：栈S已存在。
操作结果：将栈清空。
stackEmpty(LinkStack &S)
初始条件：栈S已存在。
操作结果：若S为空栈，则返回TRUE,否则返回FALSE。
getTop(LinkStack &S,SElemType &e)
初始条件：栈S已存在。
操作结果：若栈S不空，则以 e返回栈顶元素。
push(LinkStack &S,SElemType e)
初始条件：栈S已存在。
操作结果：在栈S的栈顶插入新的栈顶元素e。
pop(LinkStack &S,SElemType &e)
初始条件：栈S已存在。
操作结果：删除S的栈顶元素，并以e返回其值。
（2）其他函数
void main()
用来接受字符以使用户选择怎样的操作，并调用其他函数来实现迷宫的遍历及显示
void same(PositionType pos[MAXNUM][MAXNUM],
PositionType posCopy[MAXNUM][MAXNUM])
用来将pos数组和posCopy数组各个元素相等，即完成复位工作。
void printPathNum(PositionType pos[MAXNUM][MAXNUM])
用来打印系统找到的迷宫路径数目
void printAllPath(PositionType pos[MAXNUM][MAXNUM])
用来将所有的迷宫路径打印
void printDefaultPath(PositionType pos[MAXNUM][MAXNUM]) 用来打印系统最先生成的迷宫路径
void firstIntroduction()
用来显示第一级的说明文字
void secondIntroduction()
用来显示第二级的说明文字
int findPathNum(PositionType pos[MAXNUM][MAXNUM],LinkStack &S) 用来返回系统能找到的路径数目
int findOtherPathes(PositionType pos[MAXNUM][MAXNUM],LinkStack &S) 用来寻找其他路径
int findAnotherPath(PositionType pos[MAXNUM][MAXNUM],LinkStack &S) 用来寻找其他的一条路径
int mazePath(PositionType pos[MAXNUM][MAXNUM],LinkStack &S) 迷宫程序的核心算法之一，用来产生一条路径
PositionType * findNextPosition(PositionType * current,
PositionType pos[MAXNUM][MAXNUM],LinkStack &S)
迷宫程序的核心算法之一，用来查找下一个合适节点
void print(PositionType pos[MAXNUM][MAXNUM],LinkStack &S) 用来将迷宫打印出来
void printSign(PositionType pos[MAXNUM][MAXNUM],
PositionType * current,char a)
用来标记符号，标出所走过路径。
PositionType findEnd(PositionType pos[MAXNUM][MAXNUM]) 用来查找迷宫的根节点
PositionType findBegin(PositionType pos[MAXNUM][MAXNUM]) 用来查找迷宫的开始节点
4、实验结果『含输入数据和输出结果』
图4.1
输入c即可采用系统默认的迷宫，输入f即可使用户采用文件的形式输入迷宫，此时界面如下：
图4.2
产生路径的形式如下，用箭头可形象的指示出迷宫的走向：
图4.3
图4.4
图4.5
图4.6
5、设计体会
实验过程中的问题出现了很多，开始是语法错误，这个错误很好解决，编辑器可以提示错误的位臵，可以迅速改掉语法错误。程序死路的错误可是难上加难了。由于最初开始写代码是心中的思路并不是很成熟，第一次的代码写到一半发现不正确不得不从新开始写。后来不得不重新写代码。后期调试的过程浪费了大半部分精力，总是有些小的细节导致迷宫老是出现死循环状态。针对死循环，调试时我采用限制循环次数的方式，并且每次循环都要将栈顶打印。总的来说：只有努力，才有收获。
6、参考文献
[1] 恰汗·合孜尔［Ｍ］C语言程序设计(第三版），北京:中国铁道出版社，2010.3
[2] 严蔚敏[Ｍ] 数据结构，北京：清华大学出版社，2007
四、附录(程序清单)
#include
#include
#include "stack.h"
#define MAXNUM 8
//找到开始位置
PositionType findBegin(PositionType pos[MAXNUM][MAXNUM]){ int i,j;
for(i=0;i for(j=0;j if(pos[i][j].sign=='2'){ break; } } if(pos[i][j].sign=='2') break; } //printf("开始节点是第%d行，%d列%c",i,j,pos[i][j].sign); if(i return pos[i][j]; } return pos[0][0]; }; //找到结尾 PositionType findEnd(PositionType pos[MAXNUM][MAXNUM]){ int i,j; for(i=0;i for(j=0;j if(pos[i][j].sign=='3'){ break; } } if(pos[i][j].sign=='3') break; } if(i return pos[i][j]; } return pos[MAXNUM-1][MAXNUM-1]; }; void printSign(PositionType pos[MAXNUM][MAXNUM],PositionType * current,char a){ pos[current->row][current->col].sign=a; } //找到下一个位置 PositionType * findNextPosition(PositionType * current,PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ PositionType pt; while(1){ if(current->nextDirection==5){ //if(stackEmpty(S)==0){ printSign(pos,current,'@'); pop(S,pt); //pop(S,pt); //pop(S,pt); current=&pos[pt.row][pt.col]; //printf("%d,%d\n",current->row,current->col); //current=findNextPosition(current,pos,S); return current; //} else{ // return &pos[MAXNUM-1][MAXNUM-1]; //} } if(current->nextDirection==1){ pos[current->row][current->col].nextDirection++; if(pos[current->row][current->col+1].sign=='0'||pos[current->row] [current->col+1].sign=='1'||pos[current->row][current->col+1].sign==' 3'){ current=&pos[current->row][current->col+1]; return current; } //break; } if(current->nextDirection==2){ pos[current->row][current->col].nextDirection++; if(pos[current->row-1][current->col].sign=='0'||pos[current->row-1][current->col].sign=='1'||pos[current->row-1][current->col].sign==' 3'){ current=&pos[current->row-1][current->col]; return current; } //break; } if(current->nextDirection==3){ pos[current->row][current->col].nextDirection++; if(pos[current->row][current->col-1].sign=='0'||pos[current->row] [current->col-1].sign=='1'||pos[current->row-1][current->col].sign==' 3'){ current=&pos[current->row][current->col-1]; return current; } //break; } if(current->nextDirection==4){ pos[current->row][current->col].nextDirection++; if(pos[current->row+1][current->col].sign=='0'||pos[current->row+ 1][current->col].sign=='1'||pos[current->row+1][current->col].sign==' 3'){ current=&pos[current->row+1][current->col]; return current; } if(pos[current->row+1][current->col].sign=='@'||pos[current->row+ 1][current->col].sign=='#'){ pop(S,pt); } //break; } } } //将迷宫打印出来 void print(PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ int i,j; for(i=0;i for(j=0;j if(pos[i][j].sign=='*'){ //textcolor(RED); switch(pos[i][j].nextDirection){ case 1: case 2: printf("→"); break; case 3: printf("↑"); break; case 4: printf("←"); break; case 5: printf("↓"); break; } }else if(pos[i][j].sign=='1'||pos[i][j].sign=='0'||pos[i][j].sign=='@'||pos [i][j].sign=='#'||pos[i][j].sign=='3'){ printf("%c ",pos[i][j].sign); } else{ printf(" "); } } printf("\n"); } } //返回类型为整形，0表示找不到起点，1表示找不到终点，2表示找到路径，3表示找不到路径 int mazePath(PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ //LinkStack S; PositionType begin; PositionType end; PositionType pt; PositionType * current; PositionType * point; begin=findBegin(pos); if(begin.row==0&&begin.col==0){ return 0; } end=findEnd(pos); if(end.row==MAXNUM-1&&end.col==MAXNUM-1){ return 1; } current=&begin;//初始时指向开始位置 //printf("%c",current->sign); int allStep=0; initStack(S); //主循环体 do{ switch(current->sign){ case '1': case '2': point=current; current=findNextPosition(&pos[current->row][current->col],pos,S); //找到下一个节点 printSign(pos,point,'*'); push(S, pos[point->row][point->col]); break; case '3': //printf("当前的符号是%c,当前元素在第%d行，第%d列, nextDirection的值是%d\n",current->sign,current->row,current->col,current->nextDirectio n); push(S,pos[current->row][current->col]); break; case '0': printSign(pos,&pos[current->row][current->col],'#'); pop(S,pt); current=&pos[pt.row][pt.col]; break; case '*': if(current->nextDirection!=5){ push(S, *current); } current=findNextPosition(&pos[current->row][current->col],pos,S); //找到下一个节点 break; } allStep++; /*printf("第%d次循环\n",allStep); printf("第1行第4列的nextDirection值是%d\n",pos[1][4].nextDirection); getTop(S,pt); printf("当前栈的高度是%d\n",stackLength(S)); printf("栈顶的符号是%c,栈顶元素在第%d行，第%d列，nextDirection 的值是%d\n",pos[pt.row][pt.col].sign,pos[pt.row][pt.col].row,pos[pt.row][ pt.col].col,pos[pt.row][pt.col].nextDirection); printf("当前的符号是%c,当前元素在第%d行，第%d列, nextDirection 的值是%d\n",current->sign,current->row,current->col,current->nextDirectio n); print(pos);*/ } while(stackEmpty(S)==0 && pos[current->row][current->col].sign!='3'); if(stackLength(S)!=0){ //printf("此次路径共走了%d步,共循环了%d次。 \n",stackLength(S),allStep); //getTop(S,pt); //printf("栈顶的符号是%c,栈顶元素在第%d行，第%d列，nextDirection的值是%d\n",pos[pt.row][pt.col].sign,pos[pt.row][pt.col].row,pos[pt.row][ pt.col].col,pos[pt.row][pt.col].nextDirection); //printf("%d",stackLength(S)); //printf("该迷宫不存在通路！"); return 2; } else{ //printf("该迷宫不存在通路！"); return 3; } } //返回另外一条通路，1表示迷宫不存在通路，2表示还有其他通路 int findAnotherPath(PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ PositionType pt; int allStep=0; PositionType * current; PositionType * point; //pop(S,pt); pop(S,pt); current=&pos[pt.row][pt.col]; do{ switch(current->sign){ case '1': case '2': point=current; current=findNextPosition(&pos[current->row][current->col],pos,S); //找到下一个节点 printSign(pos,point,'*'); push(S, pos[point->row][point->col]); break; case '3': //printf("当前的符号是%c,当前元素在第%d行，第%d列, nextDirection的值是%d\n",current->sign,current->row,current->col,current->nextDirectio n); push(S,pos[current->row][current->col]); break; case '0': printSign(pos,&pos[current->row][current->col],'#'); pop(S,pt); current=&pos[pt.row][pt.col]; break; case '*': if(current->nextDirection!=5){ push(S, *current); } current=findNextPosition(&pos[current->row][current->col],pos,S); //找到下一个节点 break; } allStep++; //printf("查找其他路径的第%d次循环\n",allStep); //printf("第1行第4列的nextDirection值是%d\n",pos[1][4].nextDirection); //getTop(S,pt); //printf("当前栈的高度是%d\n",stackLength(S)); //printf("栈顶的符号是%c,栈顶元素在第%d行，第%d列，nextDirection的值是%d\n",pos[pt.row][pt.col].sign,pos[pt.row][pt.col].row,pos[pt.row][ pt.col].col,pos[pt.row][pt.col].nextDirection); //printf("当前的符号是%c,当前元素在第%d行，第%d列, nextDirection的值是%d\n",current->sign,current->row,current->col,current->nextDirectio n); //print(pos,S); } while(stackEmpty(S)==0 && pos[current->row][current->col].sign!='3'); if(stackEmpty(S)==1){ return 1; } if(pos[current->row][current->col].sign=='3'){ //printf("该迷宫还有其他通路！"); return 2; } } int findOtherPathes(PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ int state=2; int pathNumber=1; //printf("该迷宫的其他通路"); while(state==2){ pathNumber++; state=findAnotherPath(pos,S); //printf("该迷宫的其他通路"); if(state==2){ printf("第%d条路径\n",pathNumber); print(pos,S); } } return pathNumber; } int findPathNum(PositionType pos[MAXNUM][MAXNUM],LinkStack &S){ int state=2; int pathNumber=0; 目录第一部分需求分析 第二部分详细设计 第三部分调试分析 第四部分用户手册 第五部分测试结果 第六部分附录 第七部分参考文献 一、需求分析 1、对于给定的一个迷宫，给出一个出口和入口，找一条从入口到出口的通路，并把这条通路显示出来；如果没有找到这样的通路给出没有这样通路的信息。 2、可以用一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 3、编写一个求解迷宫的非递归程序。求得的通路以三元组(i，j， d)的形式输出，其中：(i，j)指示迷宫中的一个坐标，d表示走到下一坐标的方向。 4、由于迷宫是任意给定的，所以程序要能够对给定的迷宫生成对应的矩阵表示，所以程序的输入包括了矩阵的行数、列数、迷宫内墙的个数、迷宫内墙的坐标、所求的通路的入口坐标、出口坐标。 二、详细设计 1、计算机解迷宫通常用的是“穷举求解“方法，即从人口出发，顺着某一个方向进行探索，若能走通，则继续往前进；否则沿着原路 退回，换一个方向继续探索，直至出口位置，求得一条通路。假如所有可能的通路都探索到而未能到达出口，则所设定的迷宫没有通路。可以二维数组存储迷宫数据，通常设定入口点的下标为(1，1)，出口点的下标为(n，n)。为处理方便起见，可在迷宫的四周加一圈障碍。对于迷宫中任一位置，均可约定有东、南、西、北四个方向可通。2、如果在某个位置上四个方向都走不通的话，就退回到前一个位置，换一个方向再试，如果这个位置已经没有方向可试了就再退一步，如果所有已经走过的位置的四个方向都试探过了，一直退到起始点都没有走通，那就说明这个迷宫根本不通。 3、所谓"走不通"不单是指遇到"墙挡路"，还有"已经走过的路不能重复走第二次"，它包括"曾经走过而没有走通的路"。 显然为了保证在任何位置上都能沿原路退回，需要用一个"后进先出"的结构即栈来保存从入口到当前位置的路径。并且在走出出口之后，栈中保存的正是一条从入口到出口的路径。 4、若当前位置“可通”，则纳入“当前路径”，并继续朝“下一位置”探索；若当前位置“不可通”，则应顺着“来的方向”退回到“前一通道块”，然后朝着除“来向”之外的其他方向继续探索；若该通道块的四周四个方块均“不可通”，则应从“当前路径”上删除该通道块。 所谓“下一位置”指的是“当前位置”四周四个方向（东、南、西、北）上相邻的方块。假设以栈S记录“当前路径”，则栈顶中存放的 1、课程设计目的 为了配合《数据结构》课程的开设，通过设计一完整的程序，掌握数据结构的应用、算法的编写、类C语言的算法转换成C程序并用TC上机调试的基本方法特进行题目为两个链表合并的课程设计。通过此次课程设计充分锻炼有关数据结构中链表的创建、合并等方法以及怎样通过转化成C语言在微机上运行实现等其他方面的能力。 2．课程设计的内容与要求 2.1问题描述： 迷宫问题是取自心理学的一个古典实验。在该实验中，把一只老鼠从一个无顶大盒子的门放入，在盒子中设置了许多墙，对行进方向形成了多处阻挡。盒子仅有一个出口，在出口处放置一块奶酪，吸引老鼠在迷宫中寻找道路以到达出口。对同一只老鼠重复进行上述实验，一直到老鼠从入口走到出口，而不走错一步。老鼠经过多次试验最终学会走通迷宫的路线。设计一个计算机程序对任意设定的矩形迷宫如下图A所示，求出一条从入口到出口的通路，或得出没有通路的结论。 图A 2.2设计要求： 要求设计程序输出如下： (1) 建立一个大小为m×n的任意迷宫（迷宫数据可由用户输入或由程序自动生成），并在屏幕上显示出来； （2）找出一条通路的二元组（i,j）数据序列，（i,j）表示通路上某一点的坐标。 3.2 概要设计 1.①构建一个二维数组maze[M+2][N+2]用于存储迷宫矩阵 ②自动或手动生成迷宫，即为二维数组maze[M+2][N+2]赋值 ③构建一个队列用于存储迷宫路径 ④建立迷宫节点struct point,用于存储迷宫中每个节点的访问情况 ⑤实现搜索算法 ⑥屏幕上显示操作菜单 2.本程序包含10个函数： (1)主函数main() (2)手动生成迷宫函数shoudong_maze() 二、课程设计容（含技术指标） 【问题描述】 以一个mXn的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【任务要求】 首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出。其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如，对于下列数据的迷宫，输出一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…。 编写递归形式的算法，求得迷宫中所有可能的通路。 以方阵形式输出迷宫及其通路。 【测试数据】 迷宫的测试数据如下：左上角（0，1）为入口，右下角（8，9）为出口。 出口 出口 四、基本要求 1．在设计时，要严格按照题意要求独立进行设计，不能随意更改。若确因条件所限，必须要改变课题要求时，应在征得指导教师同意的前提下进行。 2．在设计完成后，应当场运行和答辩，由指导教师验收，只有在验收合格后才能算设计部分的结束。 3．设计结束后要写出课程设计报告，以作为整个课程设计评分的书面依据和存档材料。设计报告以规定格式的电子文档书写、打印并装订，报告格式严格按照模板要求撰写，排版及图、表要清楚、工整。 从总体来说，所设计的程序应该全部符合要求，问题模型、求解算法以及存储结构清晰；具有友好、清晰的界面；设计要包括所需要的辅助程序，如必要的数据输入、输出、显示和错误检测功能；操作使用要简便；程序的整体结构及局部结构要合理；设计报告要符合规。 课程负责人签名： 2011年7月1日 迷宫与栈问题 摘要 数据结构是研究与数据之间的关系，是互相之间一种或多种特定关系的数据元素的集合，我们称这一关系为数据的逻辑结构。数据结构在计算机的表示（又称映像）称为数据的物理结构，又称存储结构。 本次课程设计是迷宫求解问题，主要是模拟从入口到出口的通路。程序中的数据采取的是“栈”作为数据的逻辑结构，并且使用链式存储结构，即是实现一个以链表作存储结构的栈类型。本课程设计实现了链栈的建立，入栈，出栈，判断栈是否为空的方法，关键的是迷宫通路路径的“穷举求解”和递归求解的方法。 本课程设计重要说明了系统的设计思路、概要设计以及各个功能模块的详细设计和实现方法。 本次程序的开发工具是microsoft visual studio 2008，编程语言是C语言。 关键词：迷宫求解链栈穷举求解递归求解 数据结构课程设计——迷宫问题求解代码 问题描述及要求： 迷宫问题求解 输入： 第一行n，m表示迷宫大小n*m 之后有n行m列，全由01组成，0表示路，1表示墙 入口设为(0,0) 出口设为(n-1,m-1) 输出： 输出从入口到出口的所有不同解，每组解的第一行打印一个数表示第几组解，之后k行表示路径，如： 1 (0,0) (0,1) (1,1) 代码部分（已测试，可直接运行）： #include Point tmp; tmp.x=x+oper[i][0]; tmp.y=y+oper[i][1]; path[len]=tmp; step[tmp.x][tmp.y]=1; dfs(tmp.x,tmp.y,len+1); step[tmp.x][tmp.y]=0; } } void work(){ step[0][0]=1; Point cur; cur.x=0; cur.y=0; path[0]=cur; dfs(0,0,1); } int main(){ scanf("%d%d",&n,&m); for(int i=0;i 《数据结构与算法设计》迷宫问题实验报告 ——实验二 专业：物联网工程 班级：物联网1班 学号：15180118 姓名：刘沛航 一、实验目的 本程序是利用非递归的方法求出一条走出迷宫的路径，并将路径输出。首先由用户输入一组二维数组来组成迷宫，确认后程序自动运行，当迷宫有完整路径可以通过时，以0和1所组成的迷宫形式输出，标记所走过的路径结束程序；当迷宫无路径时，提示输入错误结束程序。 二、实验内容 用一个m*m长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序对于任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 三、程序设计 1、概要设计 （1）设定栈的抽象数据类型定义 ADT Stack{ 数据对象：D={ai|ai属于CharSet，i=1、2…n，n>=0} 数据关系：R={ StackEmpty(&S) 初始条件：栈已经存在 操作结果：判断栈是否为空。若栈为空，返回1，否则返回0 Destroy(&S) 初始条件：栈已经存在 操作结果：销毁栈s }ADT Stack （2）设定迷宫的抽象数据类型定义 ADT yanshu{ 数据对象：D={ai,j|ai,j属于{‘ ’、‘*’、‘@’、‘#’},0<=i<=M,0<=j<=N} 数据关系：R={ROW,COL} ROW={ 目录 第一章:设计问题描述与分析 (1) 1.1.课程设计内容 (1) 1.2. 问题分析 (1) 1.3．功能实现 (2) 1.4．运行环境 (3) 第二章:算法设计与流程图 (4) 2.1.主函数的流程图 (4) 2.2.概要设计 (5) 2.4详细设计 (6) 2.4.1. 节点类型和指针类型 (6) 2.4.2.迷宫的操作 (6) （1）生成迷宫 (6) （2）打印迷宫矩阵与字符图形 (7) （3）迷宫求解路由求解操作 (7) （4）打印迷宫通路坐标 (8) (5)输出迷宫通路的字符图形 (8) 2.4.3. 主函数 (9) 第三章：调试分析 (10) 第四章：使用说明 (11) 第五章：测试结果 (12) 附录1 (19) 附录2 (19) 第一章：设计问题描述与分析 1.1.课程设计内容： 该系统是由C 语言编写的生成一个N×M(N行M列)的迷宫，完成迷宫的组织和存储，并实现迷宫路由算法。基本要求1、 N和M是用户可配置的，缺省值为50和50。 2、迷宫的入口和出口分别在左上角和右下角。 提示：（1）可以使用二维数组maze[M+2][N+2]表示迷宫，其中M,N为迷宫的行、列数，当元素值为0时表示该点是通路，当元素值为1时表示该点是墙。老鼠在每一点都有4种方向可以走，可以用数组move[4]来表示每一个方向上的横纵坐标的偏移量，可用另一个二维数组mark[M+2][N+2]记录节点的访问情况。（2）可以选用深度优先算法或广度优先算法实行，迷宫可由自动或手动生成。测试用例应该包含有解迷宫和无解迷宫。 1.2. 问题分析 本程序要求实现迷宫问题的相关操作，包括迷宫的组织和存储，并实现迷宫路由算法（即查找迷宫路径）。程序所能达到的：具体包括迷宫的建立，迷宫的存储（迷宫由自动生成或手动生成），迷宫中路径的查找 迷宫是一个矩形区域，迷宫存在一个入口和一个出口，其内部包含了不能穿越的墙或者障碍。迷宫的建立即是建立这样一个迷宫矩阵，用于存储迷宫信息，包括可穿越的路和不可穿越的墙或者障碍，分别用0表示通路，1表示障碍。对于迷宫矩阵，用m×n的矩阵来描述，m和n分别代表迷宫的行数和列数。这样，则迷宫中的每个位置都可以用其行号和列号来指定。从入口到出口的路径是由一组位置构成的。每个位置上都没有障碍，且每个位置（第一个除外）都是前一个位置的上、下、左、右的邻居。 为了描述迷宫中位置（i ，j）处有无障碍，规定，当位置（i ，j）处有一个障碍时，其值为1，否则为0.这样迷宫就可以用0、1矩阵来描述，在构造矩阵时，为了操作方便会将矩阵四周置为1（不通）。 迷宫问题 ——王欣歆20080564 一．需求设计：以一个m*m 的方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口的通道，或得出没有通路的结论。二．概要设计： 存储结构： 采用了数组以及结构体来存储数据，在探索迷宫的过程中用到的栈，属于顺序存储结构。 /*八个方向的数组表示形式*/ int move[8][2]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1, 0},{-1, 1}}; /*用结构体表示位置*/ struct position { int x,y; }; position stack[m*m+1]; 基本算法： 走迷宫的过程可以模拟为一个搜索的过程：每到一处，总让它按东、东南、南、西南、西、西北、北、东北8个方向顺序试探下一个位置；如果某方向可以通过，并且不曾到达，则前进一步，在新位置上继续进行搜索；如果8个方向都走不通或曾经到达过，则退回一步，在原来的位置上继续试探下一位置。 每前进或后退一步，都要进行判断：若前进到了出口处，则说明找到了一条通路；若退回到了入口处，则说明不存在通路。 用一个字符类型的二维数组表示迷宫，数组中每个元素取值“0”（表示通路）或“1”（表示墙壁）。迷宫的入口点在位置（1，1）处，出口点在位置（m,m）处。设计一个模拟走迷宫的算法，为其寻找一条从入口点到出口点的通路。 二维数组的第0行、第m+1行、第0列、第m+1列元素全置成“1”，表示迷宫的边界；第1行第1列元素和第m行第m列元素置成“0”，表示迷宫的入口和出口；其余元素值用随机函数产生。 假设当前所在位置是（x,y）。沿某个方向前进一步，它可能到达的位置最多有8个。 如果用二维数组move记录8个方向上行下标增量和列下标增量，则沿第i个方向前进一步，可能到达的新位置坐标可利用move数组确定： x=x+move[i][0] y=y+move[i][1] 从迷宫的入口位置开始，沿图示方向顺序依次进行搜索。在搜索过程中，每前进一步，在所到位置处做标记“ ” （表示这个位置在通路上），并将该位置的坐标压入栈中。 每次后退的时候，先将当前所在位置处的通路标记“ ”改 成死路标记“×”（表示这个位置曾到达过但走不通，以后 不要重复进入），然后将该位置的坐标从栈顶弹出。 678 51 432 x y o 数据结构课程设计报告 设计题目：迷宫问题数据结构课程设计_ 班级：计科152 学号：19215225 姓名：徐昌港 南京农业大学计算机系 数据结构课程设计报告内容 一．课程设计题目 迷宫问题 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。要求：首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出。其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。 二．算法设计思想 1.需求分析 （1）迷宫数据用一个二维数组int maze[row][col]来存储，在定义了迷宫的行列数后，用两个for循环来录入迷宫数据，并在迷宫周围加墙壁。 （2）迷宫的入口位置和出口位置可以由用户自己决定。 2.概要设计 （1）主程序模块： void main() { int maze[row][col]; struct mark start,end; //出入口的坐标 int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //方向，依次是东西南北 built_maze(maze); printf("请输入入口的横纵坐标："); scanf("%d,%d",&start.a,&start.b); printf("请输入出口的横纵坐标："); scanf("%d,%d",&end.a,&end.b); printf("0为东，1为南，2为西，3为北，-1为出路\n"); maze_path(maze,dir,start,end); getchar(); } （2）栈模块——实现栈抽象数据类型 （3）迷宫模块——实现迷宫抽象数据类型，建立迷宫，找出迷宫的一条通路 3.详细设计 （1）坐标位置类型 struct mark{ int a,b; //迷宫a行b列为位置 }; （2）迷宫类型 void built_maze(int maze[row][col]) //按照用户输入的row行和col列的二维数组（元素值为0和1） //设置迷宫maze的初值，包括边上边缘一圈的值 void maze_path(int maze[row][col],int dir[4][2],struct mark start,struct mark end) //求解迷宫maze中，从入口start到出口end的一条路径， //若存在，则返回TRUE；否则返回FALSE （3）栈类型 struct element{ int i,j,d; //坐标与方向 }; typedef struct Linkstack{ element elem; 安徽建筑大学 课程设计报告 课程名称：数据结构与算法课程设计 题目：迷宫求解 院系：数理系 专业：信息与计算数学 班级： 学号： 姓名： 时间： 目录 一、需求分析 (2) 1.问题描述： (2) 2.基本要求 (2) 二、概要设计 (3) 1.数据结构 (3) 2.程序模块 (3) 3.算法设计 (5) 三、详细设计 (7) 1.数据类型定义 (7) 2.函数实现代码 (7) 3.函数之间的调用关系 (7) 四、调试分析 (7) 五、用户手册 (8) 六、测试结果 (8) 七、参考文献 (9) 八、附录 (9) 迷宫求解题目： 以一个m×n长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍，设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。(1)以二维数组存储迷宫数据； (2)求得的通路以二元组( i , j )的形式输出，其中（i, j）指示迷宫中的一个坐标。 一、需求分析 1. 问题描述： 在迷宫中求出从入口到出口的路径。经分析，一个简单的求解方法是：从入口出发，沿某一方向进行探索，若能走通，则继续向前走；否则沿原路返回，换一方向再进行搜索，直到所有可能的通路都探索到为止。即所谓的回溯法。 求迷宫中从入口到出口的所有路径是一个经典的程序设计问题。由于计算机解迷宫时，通常用的是“穷举求解”的方法，即从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直至所有可能的通路都探索到为止。为了保证在任何位置上都能沿原路退回，显然需要用一个后进先出的结构来保存从入口到当前位置的路径。因此，在求迷宫通路的算法中应用“栈”也就是自然而然的事了。 假设“当前位置”指的是“在搜索过程中某一时刻所在图中某个方块位置”，则求迷宫中一条路径的算法的基本思想是：若当前位置"可通"，则纳入"当前路径"，并继续朝“下一位置”探索，即切换“下一位置”为“当前位置”，如此重复直至到达出口；若当前位置“不可通”，则应顺着“来向”退回到“前一通道块”，然后朝着除“来向”之外的其他方向继续探索；若该通道块的四周四个方块均“不可通”，则应从“当前路径”上删除该通道块。所谓“下一位置”指的是“当前位置”四周四个方向（东、南、西、北）上相邻的方块。 2. 基本要求 （1）以二维数组maze.adr[m+1][n+1]表示迷宫，其中mg[0][j]和mg[m+1][j](0 j n)及mg[i][0]和mg[i][n](0 i m)为添加的一圈障碍，数组中以元素值为0表示通路，1表示障碍，限定迷宫大小m,n 10。 （2）用户以文件的形式输入迷宫的数据：文件中第一行的数据为迷宫的行数m 和列数n;从第2行至第m+1行（每行n个数）为迷宫值，同一行的两个数之间用空 白字符相隔。 （3）迷宫入口为（1，1），出口为（m,n）。 （4）每次移动只能从一个无障碍的单元到周围8个方向上任意无障碍的单元，编制程序给出一条通过迷宫的路径或报告一个“无法通过”的信息。 （5）本程序只求出一条成功的通路。 3．测试数据见下表，当入口为（1，1）时，出口为（8，8） 用一个字符类型的二微数组表示迷宫，数组中的每个元素表示一个小方格，取值“0”（表示可以进出）或“1”（表示不可以进出） 随机产生一个8*8的迷宫，其中使用迷宫障碍坐标如下： （1，3），（1，7），（2，3），（2，7），（3，5），（3，6）， （4，3），（4，4），（5，4），（6，2），（6，6），（7，2），（7，3）， （7，4），（7，6），（7，7），（8，1）。 信息工程学院 课程设计报告 课程名称《数据结构》 课题名称走迷宫游戏 专业 班级 学号 姓名 联系方式 指导教师 2015 年 12 月 27 日 目录 1、数据结构课程设计任务书............................................................... １ 1.1、题目........................................................................... １ 1.2、要求........................................................................... １ 2、总体设计............................................................................. １ 2.1、设计思路及总体组成框架......................................................... １ 2.2、操作流程图..................................................................... ２ 3、详细设计............................................................................. ５ 3.1、程序中所采用的数据结构及存储结构的说明......................................... ５ 3.2、函数功能模块说明............................................................... ５ 3.3、各函数的调用关系 ............................................................................................................................... ７ 4、调试与测试：......................................................................... ７ 4.1、调试方法与步骤：............................................................... ７ 4.2、测试结果的分析与讨论：......................................................... ８ 4.3、测试过程中遇到的主要问题及采取的解决措施：................................... １０ 6、源程序清单......................................................................... １０ 7、数据结构课程设计总结............................................................... １４ 8、参考文献........................................................................... １４ 迷宫实验 一．摘要 迷宫实验主要是要探讨研究一个人只靠自己的动觉，触觉和记忆获得信息的情况下，如何学会在空间中定向。本实验的被试是华东师范大学应用心理学系大二的一名女同学，本实验以学习遍数为自变量，以所用时间和错误次数为因变量，让被试在排除视觉条件下，用小棒从迷宫起点凹槽移动到达终点，其间小棒每次进入盲巷并与盲巷末端金属片接触算一次错误，学会的定义为连续三遍不出错。而且主试也不能给予被试任何提示或暗示。被试要运用动觉，思维，记忆等自己认为有效的方法独立完成。测试中为了控制疲劳带来的误差，若被试感到疲劳，可稍事休息再进行实验。分析实验数据可知，被试走完迷宫所用时间成减少趋势，错误次数也成减少趋势。在最初几次走迷宫时，错误次数会出现反复的时多时少的情况，所用时间也在反复，时多时少，这表明被试在摸索迷宫路线，处于对整个迷宫的整体定位中。随着学习遍数的增加，错误次数与走完一次迷宫所用的时间开始减少，这表明被试对于迷宫的整体情况有了比较清楚的了解。 关键词迷宫学习次数学习时间错误次数 二．引言 人类从十九世纪末就开始研究迷宫学习了。1899 年,斯莫尔(W. S. Small ) 让白鼠学习一条相当复杂的迷津通路。通过研究他认为,白鼠迷宫学习所依靠的主要是触觉和动觉记忆。1912 年希克思(V. C. Hicks) 和卡尔把迷宫用于研究人类学习。泊金斯（Perkins，1927）最早使用这种在手指迷宫的基础上发展起来的最简便、最常用的触棒迷宫（pencil maze）。近年来，学者们则利用迷宫进行逆反学习能力的研究。而在特殊教育领域，也利用迷宫队正常人和盲人进行了触棒迷宫的对比试验，并得出了盲人心理的巨大补偿作用和学习潜能的结论。 迷宫是研究一个人只靠自己的动觉、触觉和记忆获得信息的情况下，如何学会在空间中定向。迷宫的种类很多，结构方式也不一样，但是有一个特征，这就是有一条从起点到终点的正确途径与从此分出的若干条盲巷。被试的任务是寻找与巩固掌握这条正确途径。迷宫的学习一般可分为四个阶段：1.一般方位辨认。2.掌握迷宫的首段、尾段和中间的一、二部分。3.扩大可掌握的部分，直至全部掌握空间图形。4.形成集体对空间图形的自动化操作。迷宫学习与被试的智商有关，它涉及被试的空间定向能力、思维、记忆诸多方面。 在此迷宫实验中，被试排除视觉条件，用小棒从迷宫起点沿凹槽移动到达终点。在此过程中，被试要运用动觉，思维，记忆等自己认为有效 迷宫求解数据结构课程设计 《数据结构》课程设计 题目：迷宫求解 班级： 学号： 作者姓名： 指导教师： 2012年12月11日 目录 1．需求分析 (1) 2．概要设计 (1) 2.1．数据结构 (1) 2.1.1．逻辑结构 (1) 2.1.1．存储结构 (2) 2.2.基本操作 (3) 2.2.1.迷宫中栈的基本操作 (3) 2.2.2.迷宫的抽象数据类型 (3) 2.2.3.本程序包含三个模块 (4) 3．详细设计 (5) 4．调试与分析 (9) 5．用户手册 (9) 6. 测试结果 (10) 7. 附录 (12) 8. 参考文献 (12) 9、心得体会 (12) 10、小组成员工作分配 (13) 一、需求分析 (1)以二维数组maze[n+2][m+2]表示迷宫，其中：maze[0][j]和 maze[n+1][j](0<=j<=m+1)及maze[i][0]和maze[i][m+1](0<=i<=j+1)为添加的一圈障碍。数组中以元素值为0的表示通路，1表示障碍，限定迷宫的大小，m，n<=0。 (2)迷宫的入口位置和出口位置可由用户自行设定。 (3)如设定的迷宫处在通路，则值输出迷宫中的通路，即0，现实的0连起 来就是一个迷宫通路路径；如设定的迷宫中不出在通路，则输出“该迷宫找不到通路!”； (4)测试样例：输入迷宫的长宽为5和6，输入迷宫为： 1 0 0 1 1 1 0 0 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 1 0 0 0 0 当入口位置为（1,2），出口位置为（5,6）时，则输出数据为： # # # # # # # # # 0 # # 0 # # 0 0 # # 0 # # 0 0 0 0 # # # # # # # # # (5)程序执行的命令为： 1、输入迷宫的尺寸； 2、创建迷宫； 3、输入迷宫的的出入口位置； 4、求解迷宫；输出迷宫的解。 二、概要设计 2.1.数据结构 2.1.1、逻辑结构 1）栈的定义：限定仅在表尾进行插入或删除操作的线性表； 2）操作特性：后进先出; 3) ADT定义： ADT Stack{ 数据对象：D={ai|ai∈ CharSet,i=1,2,…,n,n>=0} 数据关系：R1={ 武汉东湖学院计算机科学学院 课程设计报告 课程名称数据结构课程设 题目深度与广度优先搜索 迷宫问题 专业班级（请自己填写） 学号（请自己填写） 学生姓名（请自己填写） 指导教师吴佳芬 （请自己填写）年（请自己填写）月（请自己填写）日 武汉东湖学院计算机科学学院 课程设计任务书 课程名称：数据结构课程设计 设计题目：深度与广度优先搜索：迷宫问题 专业：（请自己填写）班级：（请自己填写） 完成时间：自己填写指导教师：吴佳芬专业负责人：许先斌 武汉大学东湖分校计算机科学学院 课程设计成绩评价表 指导教师：吴佳芬年月日 （由学生完成，以下为摸版） 【软件课程设计报告目录】 1、需求分析 说明程序设计的任务，强调的是程序要做什么，明确规定： （1）输入的形式和输入值的范围； （2）输出的形式； （3）程序所能达到的功能； （4）测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。 2、概要设计 说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次（调用）关系。 3、详细设计 实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块也都需要写出伪码算法；画出函数的调用关系。 4、使用说明、测试分析及结果 （1）说明如何使用你编写的程序； （2）测试结果与分析； （3）调试过程中遇到的问题是如何解决提以及对设计与实现的回顾讨论和分析； （4）运行界面。 5、课程设计总结（设计心得） （1）你在编程过程中用时多少？多少时间在纸上设计？多少时间上机输入和调试？多少时间在思考问题？ （2）遇到了哪些难题？你是怎么克服的？ （3）你对算法有什么改正想法吗？ （4）你的收获有哪些？ 参考文献 （由学生完成，以下为摸版，编页码：共x页，第x页） 设计题目 迷宫问题求解 任务 迷宫问题是取自心理学的一个古典实验。实验中，把一只老鼠从一个没有顶的大盒子的门放入，在盒中设置了许多墙，对行进的方向形成了多处阻挡。盒子仅仅有一个出口，在出口处放置了一块奶酪，吸引老鼠在迷宫中寻找道路以到达出口。重复对老鼠进行上述实验，看老鼠能在多久找到出口。 功能要求： 请设计一个算法实现迷宫问题求解。 测试数据：0表示可以行走的区域，1表示不可行走的区域。 需求分析 该程序的实现需要用到栈，用栈来储存正确的步骤。首先要建立一个迷宫，用数组来实现。然后通过规定的放向依次探索，一步步找到正确的路径。 概要设计 typedef struct StackElem { int x; int y; int f; }StackElem; //定义栈 typedef struct { StackElem * base; StackElem * top; int StackSize; }Stack; //初始化栈 void StackInit(Stack *s) //向栈中添加元素 void Push(Stack *s,StackElem e) //获得栈顶元素 StackElem GetTop(Stack *s) /删除栈顶元素 void Pop(Stack *s) /判断当前位置是否走过（下一位置与Path中所有位置从栈顶至栈底依次比较） int unPass(Stack Path,StackElem Step /右边相邻的位置 StackElem Right(StackElem Step,int m,int n)（一共8个向函数类似） //获得下一个可通行的位置,逐个方向试探 迷宫求解 一．问题描述 对迷宫问题的求解过程实际就是从入口开始，一步一步地走到出口的过程。 基本要求： 输入一个任意大小的迷宫数据，用递归和非递归两种方法求出一条走出迷宫的路径，并将路径输出。 二．设计思路 在本程序中用两种方法求解迷宫问题-非递归算法和递归算法。 对于非递归算法采用回溯的思想，即从入口出发，按某一方向向前探索，若能走通，并且未走过，则说明某处可以到达，即能到达新点，否则试探下一方向；若所有的方向均没有通路，或无路可走又返回到入口点。在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈保存所能到达的没一点的下标及该点前进的方向，然后通过对各个点的进出栈操作来求得迷宫通路。 对于递归算法，在当前位置按照一定的策略寻找下个位置，在下个位置又按照相同的策略寻找下下个位置…；直到当前位置就是出口点，每一步的走法都是这样的。随着一步一步的移动，求解的规模不断减小；如果起始位置是出口，说明路径找到，算法结束，如果起始位置的四个方向都走不通，说明迷宫没有路径，算法也结束。 另外，为了保证迷宫的每个点都有四个方向可以试探，简化求解 过程，将迷宫四周的值全部设为1，因此将m行n列的迷宫扩建为m+2行，n+2列，同时用数组来保存迷宫阵列。 三．数据结构设计 在迷宫阵列中每个点都有四个方向可以试探，假设当前点的坐标（x，y），与其相邻的四个点的坐标都可根据该点的相邻方位而得到，为了简化问题，方便求出新点的坐标，将从正东开始沿顺时针进行的这四个方向的坐标增量放在一个结构数组move[4]中，每个元素有两个域组成，其中x为横坐标增量，y为纵坐标增量，定义如下： typedef struct { int x,y; }item; 为到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。因此，还要将从前一点到本点的方向压入栈中。栈中的元素由行、列、方向组成，定义如下： typedef struct { int x,y,d; }DataType; 由于在非递归算法求解迷宫的过程中用到栈，所以需定义栈的类型，本程序中用的是顺序栈，类型定义如下; typedef struct { DataType data[MAXSIZE]; int top; }SeqStack, *PSeqStack; 专业：计算机科学与技术 2008年10月20 日 数据结构课程设计 一、说明： 1、课程设计题目均选自《数据结构习题集》，请你根据所给页码及题目查阅相应内容，任选其一确定自己设计的题目； 2、题目一般分为基本要求和选做内容，选做内容将作为答优的基本要求； 3、课程设计的成绩分为两部分：系统演示+设计报告。 4、演示部分的检查在12教803室，在课程设计结束后一周。 5、时间：第8周周一无课时间，第8周周六、周日8:00-12:00,1:00-5:00，第9周周一无课时间。地点12教五楼机房。 二、题目： P77: 0.3-海龟作图； P80: 1.3-集合的并、交和差运算（或者1.4-长整数四则运算）； P105: 2.9-迷宫问题； P152: 5.7-表达式类型的实现； P153: 5.8-全国交通咨询模拟。 三、报告要求：完成以上实验内容并写出实验报告，报告应具有以下内容： 1、实验内容 2、概要设计 3、详细设计 4、测试数据及程序运行情况 5、实验过程中出现的问题及解决方法 6、实验体会 四、实验报告要求全部为打印稿，格式统一（见附件实验报告格式），在程序演示检查完成后一并教给老师。 五、课程设计期间有问题，请到12教803室找王永燕,周劲老师。 1、实验内容 【问题描述】 以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【基本要求】 首先实现一个链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。 【实现提示】 计算机解迷宫通常用的是“穷举求解”方法，即从入口出发，顺着某一个方向进行探索，若能走通，则继续往前进；否则沿着原路退回，换一个方向继续探索，直至出口位置，求得一条通路。假如所有可能的通路都探索到则未能到达出口，则所设定的迷宫没有通解。 可以二维数组存储迷宫数据，通常设定入口点的下标为（1，1），出口点的下标为（n,n）。为处理方便起见，可以迷宫的四周加一圈障碍。对于迷宫任一位置，均可约定有东、南、西、北四个方向可通。 【选作内容】 （１）编写递归形式的算法，求得迷宫中所有可能的通路； 《数据结构》课程设计报告-运动会分数统计一元多项式迷宫求解文章编辑纸牌游戏等 南京林业大学 数据结构课程设计报告 专业：计算机科学与技术 课程名称：数据结构 姓名： 学号：090801126 指导老师： 时间: 2011年1月 目录要点： 一.具体内容（题目） (1) 二.需求分析（功能要求） (2) 三.概要设计（程序设计思想） (3) 四.详细设计（源代码） (6) 五.调试分析（运行结果显示及说明） (31) 六．课设总结 (34) 题目1: 运动会分数统计** 任务：参加运动会有n个学校，学校编号为1……n。比赛分成m个男子项目，和w个女子项目。项目编号为男子1……m，女子m+1……m+w。不同的项目取前五名或前三名积分；取前五名的积分分别为：7，5，3，2，1，取前三名的积分分别为：5，3，2，；哪些取前五名或前三名由学生自己设定。（m〈=20，n〈=20）； 题目2：一元多项式** 任务：能够按照指数降序排列建立并输出多项式； 能够完成两个多项式的相加，相减，并将结果输入； 题目4：迷宫求解 任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出； 题目5：文章编辑** 功能：输入一页文字，程序可以统计出文字、数字、空格的个数。 静态存储一页文章，每行最多不超过80个字符，共N行； 题目6：Joseph环 任务：编号是1，2，……，n的n个人按照顺时针方向围坐一圈，每个人只有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个仍开始顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向的下一个人开始重新从1报数，如此下去，直到所有的人出列为止。设计一个程序来求出出列的顺序。 2 ##大学 数据结构课程设计报告题目：走迷宫游戏 院（系）：计算机工程学院 学生姓名: 班级：学号: 起迄日期: 2011-6-21 至 2011-6-30 指导教师: 2010—2011年度第 2 学期 一、需求分析 1 问题描述 走迷宫游戏 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处。 2 基本功能 1) 老鼠形象可辨认，可用键盘操纵老鼠上下左右移动； 2) 迷宫的墙足够结实，老鼠不能穿墙而过； 3) 正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，否则提示失败； 4) 添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙； 5) 找出走出迷宫的所有路径，以及最短路径。 利用序列化功能实现迷宫地图文件的存盘和读出等功能 3 输入输出 输入为字符型： 1， 2， 3 分别实现功能选择 w(上),s(下),a(左),d(右)控制迷宫的走向 y表示确定 n表示否定 二、 概要设计 1. 设计思路： 实现走迷宫 game （） 对迷宫地图进行修改change （） 对修改的地图数组进行保存edit （） 对修改的地图进行保存 savemap （） 实现自动搜路 Mathpath （）对搜寻的路径进行输 出 print （） 2.数据结构设计： 采用的是栈来存储数据，进栈实际是在栈中插入三元组，出栈则只数组的个数进行操作 抽象数据类型线性表的定义如下： ADT SqStack{ 数据对象：D={a i | a i ∈SElemType,i=1,2,3……，n,n ≥0} 数据关系：R1={| a i-1,a i ∈D,i=1,2,3,……，n} 基本操作： SqStack *InitStack() 操作结果：创建一个空栈 void Push(SqStack *S,SElemType data) 初始条件：栈S 已存在 操作结果：插入一个元素，并且使数据个数加一(top++) void Pop(SqStack *S) 初始条件：栈S 已存在。 操作结果：栈中元素个数减一（top--） } 2. 软件结构设计： game （）模块 函数原型： void game(int map1[h][w])//游戏函数 { #define killtime 15 clock_t start, finish; double duration; int x=1,y=1,m=0,n=0,M,N,MAP[100][100];//x->colom y->row char cCtrl='\0';数据结构课程设计-迷宫问题(参考资料)
数据结构课程设计-迷宫问题的操作
迷宫与栈问题课程设计报告
数据结构迷宫问题的C 代码
数据结构迷宫问题实验报告
迷宫问题课程设计报告
数据结构课程设计——迷宫问题课程设计报告
数据结构迷宫问题课程设计
课程设计报告示例：迷宫求解
《数据结构课程设计》走迷宫游戏
迷宫实验实验报告
迷宫求解数据结构课程设计
课程设计报告(迷宫)
c++课程设计迷宫问题求解
数据结构课程设计迷宫求解
数据结构课程设计迷宫问题
《数据结构》课程设计报告-运动会分数统计 一元多项式 迷宫求解 文章编辑 纸牌游戏等
数据结构课程设计之迷宫游戏