迷宫问题的求解的设计说明书

合集下载

数据结构课程设计迷宫问题求解

数据结构课程设计迷宫问题求解

数据结构课程设计迷宫问题求解正文:一、引言在数据结构课程设计中,迷宫问题求解是一个经典且常见的问题。

迷宫问题求解是指通过编程实现在迷宫中找到一条从起点到终点的路径。

本文将详细介绍如何用数据结构来解决迷宫问题。

二、问题分析1.迷宫定义:迷宫是由多个格子组成的矩形区域,其中包括起点和终点。

迷宫中的格子可以是墙壁(无法通过)或者通道(可以通过)。

2.求解目标:在给定的迷宫中,找到从起点到终点的一条路径。

3.输入:迷宫的大小、起点坐标、终点坐标以及墙壁的位置。

4.输出:从起点到终点的路径,或者提示无解。

三、算法设计1.基础概念a) 迷宫的表示:可以使用二维数组来表示迷宫,数组的元素可以是墙壁、通道或者路径上的点。

b) 坐标系统:可以使用(x, y)来表示迷宫中各个点的坐标。

c) 方向定义:可以用上、下、左、右等四个方向来表示移动的方向。

2.深度优先搜索算法(DFS)a) 算法思想:从起点开始,沿着一个方向一直走到无法继续为止,然后回退到上一个点,再选择其他方向继续探索。

b) 算法步骤:i) 标记当前点为已访问。

ii) 判断当前点是否为终点,如果是则返回路径;否则继续。

iii) 遍历四个方向:1.如果该方向的下一个点是通道且未访问,则继续向该方向前进。

2.如果该方向的下一个点是墙壁或已访问,则尝试下一个方向。

iv) 如果四个方向都无法前进,则回退到上一个点,继续向其他方向探索。

3.广度优先搜索算法(BFS)a) 算法思想:从起点开始,逐层向外探索,直到找到终点或者所有点都被访问。

b) 算法步骤:i) 标记起点为已访问,加入队列。

ii) 循环以下步骤直到队列为空:1.取出队首元素。

2.判断当前点是否为终点,如果是则返回路径;否则继续。

3.遍历四个方向:a.如果该方向的下一个点是通道且未访问,则标记为已访问,加入队列。

iii) 如果队列为空仍未找到终点,则提示无解。

四、算法实现1.选择合适的编程语言和开发环境。

迷宫问题说明书

迷宫问题说明书

目录摘要 (1)前言 (2)正文 (3)1.采用类C语言定义相关的数据类型 (3)2.各模块的伪码算法 (3)3.函数的调用关系图 (5)4.调试分析 (5)5.测试结果 (6)6.源程序(带注释) (9)总结 (16)参考文献 (17)致谢 (18)附件Ⅰ部分源程序代码 (19)摘要迷宫问题的求解是一个很好的在栈或者队列等方面的应用问题,本次设计是以栈去实现的。

问题的求解主要是给定一个入口坐标和出口坐标时求出一条从入口到出口的路径,如果不存在或存在要做出相应的判断,存在时打印其路径,并做动态演示。

关键字:栈,栈的存储结构,出栈与入栈前言由于计算机解迷宫时,通常用的是群举的方法,即从入口出发,顺某一方向搜索。

若能走通,则继续往前走;否则沿原路退回,换一个方向再继续搜直至所有可能的通路都搜索完为止。

为了保证在任何位置上都能沿原路返回,这就需要一个后进先出的结构来存储起位置,所以用到了栈的概念。

在问题的求解过程中,用到了对栈的定义、栈的初始化、栈的空间的申情、栈的销毁等有关栈的知识。

通过这次课程设计可让我们更深一步的了解栈的概念。

在解决问题的过程中初步懂的如何去选择合适的方法去处理问题,提高解决问题的效率。

正文1.采用类c语言定义相关的数据类型(1) void enqueue(struct point p){queue[tail]=p;tail++;}(2) struct point dequeue(void){head++;return queue[head-1]; }2.各模块的伪码算法(1)void zidong_maze(int m,int n) //自动生成迷宫问题{ system("cls");int i,j;printf("自动生成迷宫\n");printf("loading……\n");system ("pause"); //暂停for(i=0;i<m;i++)for(j=0;j<n;j++)maze[i][j]=rand()%2; }(2)void print_maze(int m,int n){ int i,j;for(i=0;i<n;i++) /*迷宫外围设置封闭*/ {maze[i][0]=1;maze[i][n-1]=1;maze[0][i]=1;maze[n-1][i]=1;}for(i=0;i<m;i++){ printf("\n");for(j=0;j<n;j++)printf("%d",maze[i][j]);}(3)void enqueue(struct point p){queue[tail]=p;tail++;}(4)struct point dequeue(void){head++;return queue[head-1]; }3.函数的调用关系图4.调试分析a、调试中遇到的问题及对问题的解决方法(1)在输入迷宫时m,n不合适,导致程序出错解决方法:while(m>50||n>50){printf("\n");printf(":\n");scanf("%d",&m);printf(":\n");scanf("%d",&n);}b、算法的时间复杂度和空间复杂度空间复杂度:4.27kb;时间复杂度:O(n);5.测试结果a.欢迎界面:输入行,列:选择界面:运行结果:6.源程序(带注释)#include"iostream"#include"stdlib.h"using namespace std;#define N 50#define M 50int maze[N+2][M+2];struct point {int row, col, predecessor;}queue[512];int head=0, tail=0;void zidong_maze(int m,int n) //自动生成迷宫问题{ system("cls");int i,j;printf("自动生成迷宫\n");printf("loading……\n");system ("pause"); //暂停for(i=0;i<m;i++)for(j=0;j<n;j++)maze[i][j]=rand()%2; //0、1随机数产生,生成迷宫}void print_maze(int m,int n){ int i,j;for(i=0;i<n;i++) /*迷宫外围设置封闭*/{maze[i][0]=1;maze[i][n-1]=1;maze[0][i]=1;maze[n-1][i]=1;}for(i=0;i<m;i++){ printf("\n");for(j=0;j<n;j++)printf("%d",maze[i][j]);}}void build_maze(int m,int n){ system("cls");printf("生成结果\n");printf("迷宫入口\n");printf("↓");print_maze(m,n);printf("→迷宫出口\n");}void result_maze(int m,int n) //迷宫生成图形{int i,j;printf("迷宫生成图形如下所示: \n");for(i=0;i<m;i++){printf("\n");for(j=0;j<n;j++){ if(maze[i][j]==0)printf(" ");if(maze[i][j]==1)printf("■");}}}void enqueue(struct point p){queue[tail]=p;tail++;}struct point dequeue(void){head++;return queue[head-1]; }int is_empty(void){return head==tail; }void visit(int row,int col,int maze[52][52]){ struct point visit_point={row,col,head-1};maze[row][col]=2;enqueue(visit_point);}int mgpath(int maze[52][52],int m,int n){ struct point p={0,0,-1};if(maze[p.row][p.col]==1){printf("此迷宫无解\n\n");return 0;}maze[p.row][p.col]=2;enqueue(p);while (!is_empty()){ p=dequeue();if (p.row==m-1&&p.col==n-1) //goalbreak;if(p.col+1<n&&maze[p.row][p.col+1]==0) //rightvisit(p.row,p.col+1,maze);if(p.row+1<m&&maze[p.row+1][p.col]==0) //downvisit(p.row+1,p.col,maze);if(p.col-1>=0&&maze[p.row][p.col-1]==0) //leftvisit(p.row,p.col-1,maze);if(p.row-1>=0&&maze[p.row-1][p.col]==0) //upvisit(p.row-1,p.col,maze);print_maze(m,n);printf("\n------------------------------\n");}if(p.row==m-1&&p.col==n-1){ printf("迷宫路径为:\n");printf("(%d,%d)\n",p.row, p.col);maze[p.row][p.col]=3;while(p.predecessor !=-1){p=queue[p.predecessor];printf("(%d,%d)\n",p.row,p.col);maze[p.row][p.col]=3;}} elseprintf("此迷宫无解!\n");return 0;}void menu(){ int m,n; //控制迷宫的行数和列数int cycle; //循环控制int choice; //选择printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n");printf("■■■■************欢迎进入用户界面************■■■■\n");printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n");while(cycle!=-1){printf("请输入行数:\n");scanf("%d",&m);printf("请输入列数:\n");scanf("%d",&n);while(m>50||n>50){printf("\n");printf(":\n");scanf("%d",&m);printf(":\n");scanf("%d",&n);}if(m<=50&&n<=50){choice=2;while(choice==2){system("cls"); //系统清屏函数printf("进入选择界面:\n");printf("1_________________自动生成迷宫\n");printf("2_________________迷宫行列数输入有误,请重新输入\n");printf("请输入选择\n");scanf("%d",&choice);switch(choice){case 1:zidong_maze(m,n);build_maze(m,n);break;case 2:system("cls");printf("请输入行数:\n");scanf("%d",&m);printf("请输入列数:\n");scanf("%d",&n);while(m>50||n>50){printf("行列数超出预设范围,请重新输入\n");printf("请输入行数\n");scanf("%d",&m);printf("请输入列数\n");scanf("%d",&n);} }} }mgpath(maze,m,n); //寻找迷宫路由result_maze(m,n); //打印出迷宫图形及路径printf("\n 是否重新输入迷宫,如果不继续,按-1退出\n");scanf("%d",&cycle);}}void main(){ system("color f5"); //系统函数menu();}总结在这三周的数据结构课程设计中,我的题目是:迷宫问题,这三周课程设计中,通过该题目的设计过程,我加深了对栈的逻辑结构,存储结构及入栈出栈过程的理解,对栈的基本运算的实现有所掌握,对课本中所学的各种数据结构进一步理解和掌握,学会了如何把学到的知识用于解决实际问题,锻炼了自己动手的能力。

迷宫求解课程设计说明书

迷宫求解课程设计说明书

数据结构课程设计设计说明书迷宫问题求解学生姓名学号班级成绩指导教师计算机科学与技术系2011年 9 月 9 日数据结构课程设计评阅书题目迷宫问题求解学生姓名学号指导教师评语及成绩成绩:教师签名:年月日答辩教师评语及成绩成绩:教师签名:年月日教研室意见总成绩:室主任签名:年月日注:指导教师成绩60%,答辩成绩40%,总成绩合成后按五级制记入。

课程设计任务书2011 —2012 学年第一学期专业:学号:姓名:课程设计名称:数据结构课程设计设计题目:迷宫问题求解完成期限:自 2011 年 8 月 29 日至 2011 年 9 月 9 日共 2 周设计依据、要求及主要内容(可另加附页):输入一个任意大小的迷宫数据,设置入口、出口及障碍,借助栈结构求解走出迷宫的路径并输出。

1.遵循结构化程序设计思想,采用C/C++实现。

2.界面友好,操作简便,容错性。

基本要求如下:1)问题分析和任务定义:根据设计题目的要求,充分地分析和理解问题,明确问题要求做什么?(而不是怎么做?)限制条件是什么?确定问题的输入数据集合。

2)逻辑设计:对问题描述中涉及的操作对象定义相应的数据类型,并按照以数据结构为中心的原则划分模块,定义主程序模块和各抽象数据类型。

逻辑设计的结果应写出每个抽象数据类型的定义(包括数据结构的描述和每个基本操作的功能说明),各个主要模块的算法,并画出模块之间的调用关系图;3)详细设计:定义相应的存储结构。

在这个过程中,要综合考虑系统功能,使得系统结构清晰、合理、简单和易于调试,抽象数据类型的实现尽可能做到数据封装,基本操作的规格说明尽可能明确具体。

详细设计的结果是对数据结构和基本操作做出进一步的求精,写出数据存储结构的类型定义;4)程序编码:把详细设计的结果进一步求精为程序设计语言程序。

同时加入一些注解和断言,使程序中逻辑概念清楚;5)程序调试与测试:能够熟练掌握调试工具的各种功能,设计测试数据确保程序正确。

数据结构程序设计(迷宫问题)

数据结构程序设计(迷宫问题)

数据结构程序设计(迷宫问题)数据结构程序设计(迷宫问题)一、引言迷宫问题是计算机科学中常见的问题之一,它涉及到了数据结构的设计和算法的实现。

本文将介绍迷宫问题的定义、常见的解决算法和程序设计思路。

二、问题定义迷宫问题可以描述为:给定一个迷宫,迷宫由若干个连通的格子组成,其中有些格子是墙壁,有些格子是路径。

任务是找到一条从迷宫的起点(通常是左上角)到终点(通常是右下角)的路径。

三、基本数据结构1.迷宫表示:迷宫可以使用二维数组来表示,数组中的每个元素代表一个格子,可以用0表示路径,用1表示墙壁。

2.坐标表示:可以使用二维坐标表示迷宫中的每一个格子,使用(x, y)的形式表示。

四、算法设计1.深度优先搜索算法:深度优先搜索算法可以用来解决迷宫问题。

算法从起点开始,尝试向四个方向中的一个方向前进,如果可以移动则继续向前,直到到达终点或无法继续移动。

如果无法继续移动,则回溯到上一个节点,选择另一个方向继续搜索,直到找到一条路径或者所有路径都已经探索完毕。

2.广度优先搜索算法:广度优先搜索算法也可以用来解决迷宫问题。

算法从起点开始,先将起点加入队列,然后不断从队列中取出节点,并尝试向四个方向中的一个方向移动,将新的节点加入队列。

直到找到终点或者队列为空,如果队列为空则表示无法找到路径。

五、程序设计思路1.深度优先搜索算法实现思路:a) 使用递归函数来实现深度优先搜索算法,参数为当前节点的坐标和迷宫数据结构。

b) 判断当前节点是否为终点,如果是则返回成功。

c) 判断当前节点是否为墙壁或已访问过的节点,如果是则返回失败。

d) 将当前节点标记为已访问。

e) 递归调用四个方向,如果存在一条路径则返回成功。

f) 如果四个方向都无法找到路径,则将当前节点重新标记为未访问,并返回失败。

2.广度优先搜索算法实现思路:a) 使用队列保存待访问的节点。

b) 将起点加入队列,并标记为已访问。

c) 不断从队列中取出节点,尝试向四个方向移动,如果新的节点未被访问过且不是墙壁,则将新的节点加入队列,并标记为已访问。

迷宫问题求解算法设计实验报告

迷宫问题求解算法设计实验报告

迷宫问题求解算法设计实验报告一、引言迷宫问题一直是计算机科学中的一个经典问题,其解决方法也一直是研究者们探讨的重点之一。

本实验旨在通过设计不同的算法,对迷宫问题进行求解,并对比不同算法的效率和优缺点。

二、算法设计1. 暴力搜索算法暴力搜索算法是最简单直接的求解迷宫问题的方法。

其基本思路是从起点开始,按照某种规则依次尝试所有可能的路径,直到找到终点或所有路径都被尝试过为止。

2. 广度优先搜索算法广度优先搜索算法也称为BFS(Breadth First Search),其基本思路是从起点开始,按照层次依次遍历每个节点,并将其相邻节点加入队列中。

当找到终点时,即可得到最短路径。

3. 深度优先搜索算法深度优先搜索算法也称为DFS(Depth First Search),其基本思路是从起点开始,沿着某一个方向走到底,再回溯到上一个节点继续向其他方向探索。

当找到终点时,即可得到一条路径。

4. A* 算法A* 算法是一种启发式搜索算法,其基本思路是综合考虑节点到起点的距离和节点到终点的距离,选择最优的路径。

具体实现中,可以使用估价函数来计算每个节点到终点的距离,并将其加入优先队列中。

三、实验过程本实验使用 Python 语言编写程序,在不同算法下对迷宫问题进行求解。

1. 数据准备首先需要准备迷宫数据,可以手动输入或从文件中读取。

本实验使用二维数组表示迷宫,其中 0 表示墙壁,1 表示路径。

起点和终点分别用 S 和 E 表示。

2. 暴力搜索算法暴力搜索算法比较简单直接,只需要按照某种规则遍历所有可能的路径即可。

具体实现中,可以使用递归函数来实现深度遍历。

3. 广度优先搜索算法广度优先搜索算法需要使用队列来存储待遍历的节点。

具体实现中,每次从队列中取出一个节点,并将其相邻节点加入队列中。

4. 深度优先搜索算法深度优先搜索算法也需要使用递归函数来实现深度遍历。

具体实现中,在回溯时需要将已经访问过的节点标记为已访问,防止重复访问。

数据结构课程设计报告-迷宫求解

数据结构课程设计报告-迷宫求解

数据构造课程设计陈述------迷宫问题求解学号:1315925375姓名:刘晓龙班级:13移动1班指点先生:钱鸽目次一.需求剖析1二.数据构造21. 数据构造设计斟酌22. 逻辑构造存储构造3三.算法设计3四.调试剖析8五.程序实现及测试8六.领会及缺少之处9七.参考文献9八.源代码10一.需求剖析本课程设计是解决迷宫求解的问题,从进口动身,顺某一偏向向前摸索,若能走通,则持续往前走;不然沿原路退回,换一个偏向再持续摸索,直至所有可能的通路都摸索到为止.为了包管在任何地位上都能沿原路退回,显然须要用一个落后先出的构造来保管从进口到当前地位的路径.是以,在求迷宫通路的算法中要运用“栈”的思惟假设“当前地位”指的是“在搜刮进程中的某一时刻地点图中某个方块地位”,则求迷宫中一条路径的算法的根本思惟是:若当前地位“可通”,则纳入“当前路径”,并持续朝“下一地位”摸索,即切换“下一地位”为“当前地位”,如斯反复直至到达出口;若当前地位“不成通”,则应顺着“来向”退回到“前一通道块”,然后朝着除“来向”之外的其他偏向持续摸索;若该通道块的周围4个方块均“不成通”,则应从“当前路径”上删除该通道块.所谓“下一地位”指的是当前地位周围4个偏向(上.下.左.右)上相邻的方块.假设以栈记载“当前路径”,则栈顶中存放的是“当前路径上最后一个通道块”.由此,“纳入路径”的操纵即为“当前地位入栈”;“从当前路径上删除前一通道块”的操纵即为“出栈”.二.数据构造1. 数据构造设计斟酌1) 树立一个二维数组暗示迷宫的路径(0暗示通道,1暗示墙壁);2) 创建一个栈,用来存储“当前路径”,即“在搜刮进程中某一时刻地点图中某个方块地位”.2. 逻辑构造存储构造1) 创建一个Int类型的二维数组int maze[n1][n2],用来存放0和1 (0暗示通道,1暗示墙壁);2) 创建一个构造体用来储存数组信息构造体:typedef struct//迷宫内部设置{int shu[16][16];int row;int col;}Maze;创造一个链栈struct node{int row;int col;struct node *next;};三.算法设计起首,创建数组的大小,此数组大小请求用户本身输入.具体算printf("输出神宫的外形!\n");scanf("%d%d",&x,&y);Maze m;CreatInit(&m,x,y);函数:void CreatInit(Maze *m,int x,int y)//创建迷宫{printf("please input number:\n");int i,j;for(i=0;i<=x;i++){for(j=0;j<=y;j++)m->shu[i][j] = 2;}for(i=1;i<=x;i++)for(j=1;j<=y;j++)scanf("%d",&m->shu[i][j]);m->row = x;m->col = y;}个中的0和1分离是暗示通路和障碍,界说的数组其实就是迷宫的其次,产生迷宫,算法:for(i=1;i<=x;i++){for(j=1;j<=y;j++)printf("%d\t",m.shu[i][j]);printf("\n");}最后,迷宫寻路,在寻路的时刻,我们应从输入的进口地位进出神宫,当迷宫的进口处有障碍或者出口被堵,再或者没有通路时全部程序停止,并输出迷宫无解的提醒.假如迷宫求解进程中没有消失无解情形,那么在求解的进程中,会输出迷宫的通路路径,并且输出坐标值,让运用者更清晰路径的走法.在寻路的进程中,每走过一个格,谁人格得知就会被赋值为-1,用来标识表记标帜此处已走过,免除了来往返回的重走,以免消失逝世轮回,如许程序就能从进口进入到迷宫当中.假如在迷宫当中没有通路的话,可以停止轮回输出“迷宫无解!”,则当迷宫假如消失有解时,就会输出路径.如许就简略的实现了,有解无解的输出.从而实现了请求的程序!代码如下:while((x1 >= 1 && x1 <= x) || (y1 >= 1 && y1 <= y)){if(x1 == x2 && y1 == y2){break;}if(m.shu[x1][y1+1] == 0 ) {y1=y1+1;push(x1,y1);m.shu[x1][y1] = -1; continue;}if(m.shu[x1-1][y1]==0 ) {x1=x1-1;push(x1,y1);m.shu[x1][y1] = -1; continue;}if(m.shu[x1][y1-1]==0 ) {y1=y1-1;push(x1,y1);m.shu[x1][y1]= -1;continue;}if(m.shu[x1+1][y1]==0 ){x1=x1+1;push(x1,y1);m.shu[x1][y1]= -1;continue;}pop();if(p->next==NULL)break;x1=p->row;y1=p->col;}if(x1 == x2 && y1 == y2){while(p->next != NULL){printf("%d %d\n",p->row,p->col); pop();}}elseprintf("No Answer !!!");个中要追求所有的通路,在这里则运用了一个while轮回,如许可以找到所有的通路.图解剖析:整体流程图:迷宫内部操纵流程图:四.调试剖析第一个问题,在刚开端的调试进程中,我们碰到了,无法断定走过的旅程,从而消失了逝世轮回,导致程序不克不及正常进行,但是经由我们的评论辩论,我们想出用标识表记标帜的办法来解决,也就是让走过的旅程全给标示了,如许就不会再走反复的路.第二个问题,就是性用菜单来实现操纵,那样程序的操纵性就会更强,所以我们就要把所有的办法,给写成一个个的函数来挪用,如许就碰到了参量传递的问题,但是经由我们的参考以及从书本上的实例,我们慢慢地更深的懂得到了参量传递的运用,那么这个问题也就水到渠成了.从此我们实现了菜单操纵!五.程序实现及测试运行界面:开端界面六.领会及缺少之处经由过程此次课程设计,是我对于数据构造有了更深的懂得,更新的熟悉.数据构造是一门主要的课程,只稀有据构造学得扎实了,才干对于盘算机有更深的运用,所以学好数据构造是很主要的.经由两周的上机设计,我实现了简略的迷宫求解,可以或许简略的实现求解进程.但是还消失着缺少之处,本程序不克不及轮回履行,只能履行一次.有待改良!七.参考文献1.《数据构造(c说话版) 》严蔚敏清华大学出版社2.《数据构造试验教程》李业丽.郑良斌《数据构造》高教出版社3.《数据构造习题》李春保清华大学出版社4.《数据构造习题》严蔚敏清华大学出版社5.《C说话与数据构造》王立柱清华大学出版社6.《数据构造(C说话篇)习题与解析》李春保清华大学出版社.八.源代码#include <stdio.h>#include <stdlib.h>typedef struct//迷宫内部设置{int shu[16][16];int row;int col;}Maze;struct node{int row;int col;struct node *next;};struct node *p;void push(int x1,int y1){struct node *a;a=(struct node *)malloc(sizeof(struct node)); a->row=x1;a->col=y1;a->next=p;p=a;}void pop(void){struct node *q;q=p;p=p->next;free(q);}void CreatInit(Maze *m,int x,int y)//创建迷宫{printf("please input number:\n");int i,j;for(i=0;i<=x;i++){for(j=0;j<=y;j++)m->shu[i][j] = 2;}for(i=1;i<=x;i++)for(j=1;j<=y;j++)scanf("%d",&m->shu[i][j]);m->row = x;m->col = y;}void menu(){printf("\n*************************\n"); printf("迎接进出神宫\n");printf("1.进出神宫\n");printf("2.退出\n");}int main(void){int t;int x,y;int x1,y1;int x2,y2;int i,j;while(1){menu();printf("请选择:");scanf("%d",&t);if(t == 2)break;printf("输出神宫的外形!\n");scanf("%d%d",&x,&y);Maze m;CreatInit(&m,x,y);for(i=1;i<=x;i++){for(j=1;j<=y;j++)printf("%d\t",m.shu[i][j]);printf("\n");}printf("输入进口地位:");scanf("%d%d",&x1,&y1);printf("输入出口的地位:");scanf("%d%d",&x2,&y2);p=(struct node *)malloc(sizeof(struct node)); p->row=0;p->col=0;p->next=NULL;push(x1,y1);while((x1 >= 1 && x1 <= x) || (y1 >= 1 && y1 <= y)) {if(x1 == x2 && y1 == y2){break;}if(m.shu[x1][y1+1] == 0 ){y1=y1+1;push(x1,y1);m.shu[x1][y1] = -1;continue;}if(m.shu[x1-1][y1]==0 ){x1=x1-1;push(x1,y1);m.shu[x1][y1] = -1;continue;}if(m.shu[x1][y1-1]==0 ){y1=y1-1;push(x1,y1);m.shu[x1][y1]= -1; continue;}if(m.shu[x1+1][y1]==0 ) {x1=x1+1;push(x1,y1);m.shu[x1][y1]= -1; continue;}pop();if(p->next==NULL) break;x1=p->row;y1=p->col;}if(x1 == x2 && y1 == y2) {while(p->next != NULL) {printf("%d %d\n",p->row,p->col); pop();}}elseprintf("No Answer !!!");}return 0;}。

迷宫求解课程设计(完整)

迷宫求解课程设计(完整)

一、需求分析本课程设计是解决迷宫求解的问题,从入口出发,顺某一方向向前探索,若能走通,则继续往前走;否则沿原路退回,换一个方向再继续探索,直至所有可能的通路都探索到为止。

为了保证在任何位置上都能沿原路退回,显然需要用一个后进先出的结构来保存从入口到当前位置的路径。

因此,在求迷宫通路的算法中要应用“栈”的思想假设“当前位置”指的是“在搜索过程中的某一时刻所在图中某个方块位置”,则求迷宫中一条路径的算法的基本思想是:若当前位置“可通”,则纳入“当前路径”,并继续朝“下一位置”探索,即切换“下一位置”为“当前位置”,如此重复直至到达出口;若当前位置“不可通”,则应顺着“来向”退回到“前一通道块”,然后朝着除“来向”之外的其他方向继续探索;若该通道块的四周4个方块均“不可通”,则应从“当前路径”上删除该通道块。

所谓“下一位置”指的是当前位置四周4个方向(东、南、西、北)上相邻的方块。

假设以栈S记录“当前路径”,则栈顶中存放的是“当前路径上最后一个通道块”。

由此,“纳入路径”的操作即为“当前位置入栈”;“从当前路径上删除前一通道块”的操作即为“出栈”。

二、数据结构1. 数据结构设计考虑1) 建立一个二维数组表示迷宫的路径(0表示通道,1表示墙壁);2) 创建一个栈,用来存储“当前路径”,即“在搜索过程中某一时刻所在图中某个方块位置”。

2. 逻辑结构存储结构1) 创建一个Int类型的二维数组int maze[n1][n2],用来存放0和1 ;2) 创建一个结构体用来储存数组信息(数组的横坐标X,数组的纵坐标Y,方向C)typedef struct node{int x;int y;int c;}linkstack;3) 创造一个栈包括(top表示栈顶元素)linkstack top[n1*n2];三、算法设计首先,创建数组的大小,此数组大小要求用户自己输入。

具体算法:printf("输入迷宫大小(提示:行列数不能超过50!):");scanf("%d",&g);printf("大小创建完毕,请输入迷宫:\n");其次,用户自己定义迷宫的内容,算法:void shuzu(int g,int h){int a,b;for(a=0;a<g;a++)for(b=0;b<h;b++)scanf("%d",&maze[a][b]);}第三,产生迷宫,算法:void scsu(int g,int h){int a,b;printf("生成的迷宫是:\n");for(a=0;a<g;a++){ for(b=0;b<h;b++)printf(maze[a][b]?"#":" ");printf("\n");}}最后,迷宫寻路找到出口,其算法见源代码。

数据结构课程设计-迷宫问题

数据结构课程设计-迷宫问题

数据结构课程设计-迷宫问题正文:一、引言本文档旨在设计一个解决迷宫问题的数据结构课程项目。

迷宫问题是一个典型的寻路问题,要求从起点出发,在迷宫中找到一条路径到达终点。

迷宫由多个房间组成,这些房间之间通过门相连。

二、问题描述迷宫问题包含以下要素:1.迷宫的拓扑结构:迷宫由多个房间和门组成,每个房间有四面墙壁,每面墙壁可能有门或者是封闭的。

迷宫的起点和终点是预先确定的。

2.寻路算法:设计一个算法,在迷宫中找到一条从起点到终点的路径。

路径的选择标准可以是最短路径、最快路径或者其他约束条件。

3.可视化展示:实现一个可视化界面,在迷宫中展示起点、终点、路径,用于直观地演示解决方案。

三、设计思路1.数据结构设计:选择合适的数据结构来表示迷宫和路径,例如使用二维数组或者图来表示迷宫的拓扑结构,使用栈或队列来辅助寻路算法的实现。

2.寻路算法设计:可以使用深度优先搜索、广度优先搜索、Dijkstra算法、A算法等经典算法来实现寻路功能。

根据实际需求选择最合适的算法。

3.可视化展示设计:使用图形界面库(如Tkinter、Qt等)创建迷宫展示窗口,并实时更新迷宫的状态、路径的变化。

可以通过颜色、动画等方式增加交互性。

四、实现步骤1.创建迷宫:根据预设的迷宫大小,使用数据结构来创建对应的迷宫数据。

2.设定起点和终点:在迷宫中选择起点和终点的位置,将其标记出来。

3.寻路算法实现:根据选择的寻路算法,在迷宫中找到一条路径。

4.可视化展示:使用图形界面库创建窗口,并将迷宫、起点、终点、路径等信息展示出来。

5.更新迷宫状态:根据算法实现的过程,实时更新迷宫中的状态,并将路径显示在迷宫上。

附件:1.代码实现:包含迷宫创建、寻路算法实现和可视化展示的源代码文件。

2.演示视频:展示项目实际运行效果的视频文件。

法律名词及注释:1.数据结构:指在计算机科学中定义和组织数据的方式和方式的基础设施。

2.寻路算法:用于解决寻找路径的问题的算法。

迷宫问题求解课程设计

迷宫问题求解课程设计

迷宫问题求解课程设计一、课程目标知识目标:1. 学生能理解迷宫问题的基本概念,掌握迷宫的图形表示和抽象表示方法。

2. 学生能掌握深度优先搜索、广度优先搜索等基本算法,并运用到迷宫问题求解中。

3. 学生能了解启发式搜索算法,如A*算法,并理解其在迷宫问题中的应用。

技能目标:1. 学生能够运用所学算法,独立设计并实现迷宫问题的求解程序。

2. 学生能够分析不同算法在解决迷宫问题时的优缺点,并进行比较和优化。

3. 学生能够通过小组合作,共同探讨迷宫问题的解决方案,提高团队协作和沟通能力。

情感态度价值观目标:1. 学生培养对算法和编程的兴趣,激发学习计算机科学的热情。

2. 学生通过解决实际问题,增强自信心和成就感,提高面对复杂问题的勇气和毅力。

3. 学生在团队协作中学会尊重他人、倾听意见,培养良好的合作精神和沟通能力。

分析课程性质、学生特点和教学要求:本课程为信息技术或计算机科学相关课程,旨在培养学生运用算法解决实际问题的能力。

学生处于中学高年级,具备一定的编程基础和逻辑思维能力。

教学要求注重理论与实践相结合,鼓励学生动手实践和合作探究,以实现以下具体学习成果:1. 学生能够自主设计并实现迷宫问题的求解程序。

2. 学生能够分析比较不同算法的性能,并进行优化。

3. 学生能够在团队中发挥各自优势,共同解决问题,提高沟通和协作能力。

二、教学内容1. 迷宫问题基本概念:迷宫的图形表示与抽象表示,介绍迷宫问题的定义和特点。

相关教材章节:第二章 算法基础,第三节 图的表示与应用。

2. 深度优先搜索算法:算法原理、实现步骤,以及在迷宫问题中的应用。

相关教材章节:第三章 搜索算法,第一节 深度优先搜索。

3. 广度优先搜索算法:算法原理、实现步骤,以及在迷宫问题中的应用。

相关教材章节:第三章 搜索算法,第二节 广度优先搜索。

4. 启发式搜索算法:A*算法原理、实现步骤,以及在迷宫问题中的应用。

相关教材章节:第三章 搜索算法,第四节 启发式搜索。

数据结构课程设计_迷宫求解

数据结构课程设计_迷宫求解

迷宫求解一.问题描述对迷宫问题的求解过程实际就是从入口开始,一步一步地走到出口的过程。

基本要求:输入一个任意大小的迷宫数据,用递归和非递归两种方法求出一条走出迷宫的路径,并将路径输出。

二.设计思路在本程序中用两种方法求解迷宫问题-非递归算法和递归算法。

对于非递归算法采用回溯的思想,即从入口出发,按某一方向向前探索,若能走通,并且未走过,则说明某处可以到达,即能到达新点,否则试探下一方向;若所有的方向均没有通路,或无路可走又返回到入口点。

在求解过程中,为了保证在到达某一点后不能向前继续行走(无路)时,能正确返回前一点以便继续从下一个方向向前试探,则需要用一个栈保存所能到达的没一点的下标与该点前进的方向,然后通过对各个点的进出栈操作来求得迷宫通路。

对于递归算法,在当前位置按照一定的策略寻找下个位置,在下个位置又按照相同的策略寻找下下个位置…;直到当前位置就是出口点,每一步的走法都是这样的。

随着一步一步的移动,求解的规模不断减小;如果起始位置是出口,说明路径找到,算法结束,如果起始位置的四个方向都走不通,说明迷宫没有路径,算法也结束。

另外,为了保证迷宫的每个点都有四个方向可以试探,简化求解过程,将迷宫四周的值全部设为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;四.功能函数设计(1)函数PSeqStack Init_SeqStack()此函数实现对栈的初始化工作。

迷宫求解

迷宫求解

数据结构实验报告——迷宫求解1、问题描述以一个m x n的长方矩阵表示迷宫,0和1分别表示迷宫中的通路和障碍。

设计一个程序,对任意设定的迷宫,求出从入口到出口的通路,或者没有通路的结论。

2、需求分析1、以二维数组migong[M][N]表示迷宫,其中migong[0][j]和migong[i][0](0<=j,i<=N)为添加的一圈障碍。

数组中以元素0表示通路,1表示障碍,迷宫的大小理论上可以不限制。

2、迷宫数据由程序提供,用户只需要进行选择迷宫就行。

迷宫的入口和出口由程序提供。

3、若设定的迷宫存在通路,则以长方形矩阵的形式将迷宫及其通路输出到标准终端上,其中“0”表示障碍,“2”表示通过的路径,“3”表示死胡同,没有显示的区域表示没有到达过的地方。

4、本程序只求出一条成功的通路。

但是只要对函数进行小量的修改,就可以求出其他全部的路径。

5、程序执行命令为:(1)、创建迷宫;(2)、求解迷宫;(3)、输出迷宫。

3、概要设计a、设定栈的抽象数据类型定义:ADT zhan{数据对象:D={ai|ai属于yanshu,i=1、2…n,n>0}数据关系:R={<ai-1,ai>|ai-1,ai属于D,i=2,3,…n}基本操作:gouzhan(*s,*migong)操作结果:构造一个空栈push(*s,*e)初始条件:栈已经存在操作结果:将e所指向的数据加入到栈s中pop(*s,*e)初始条件:栈已经存在操作结果:若栈不为空,用e返回栈顶元素,并删除栈顶元素getpop(*s,*e)初始条件:栈已经存在操作结果:若栈不为空,用e返回栈顶元素popover(*s)初始条件:栈已经存在操作结果:输出栈中的所有元素,同时清空栈stackempty(*s)初始条件:栈已经存在操作结果:判断栈是否为空。

若栈为空,返回1,否则返回0destroy(*s)初始条件:栈已经存在操作结果:销毁栈s}ADT zhanb、设定迷宫的抽象数据类型定义ADT yanshu{数据对象:D={ai,j|ai,j属于{‘’、‘0’、‘2’、‘3’},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}基本操作:gouzhaomigong(*migong,m,n)初始条件:二维数组migong[m][n]已经存在,其中第1至第m-1行,每行自第1到第n-1列的元素已经值,并以值0表示障碍,值1表示通路。

迷宫问题课程设计

迷宫问题课程设计

迷宫问题课程设计问题描述与需求分析本课程设计旨在解决迷宫问题,即设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

具体要求如下:输入一个m×n的长方阵表示迷宫,其中1表示通路,0表示障碍。

输出一条从入口到出口的通路,或得出没有通路的结论。

实现一个以链表作存储结构的栈类型,用于求解迷宫的非递归程序。

输出的通路以三元组(i,j,d)的形式表示,其中(i,j)指示迷宫中的一个坐标,d表示走到下一坐标的方向。

设计存储结构设计本程序采用链表作为存储结构,实现一个以链表作存储结构的栈类型。

设定栈的抽象数据类型定义如下:typedef struct StackNode{int row。

//行坐标int col。

//列坐标int dir。

//方向struct ___;StackNode。

*Stack;其中,row和___表示坐标,dir表示方向,next表示指向下一个节点的指针。

设定迷宫的抽象数据类型为:typedef struct Maze{int **maze。

//迷宫数组int rows。

//行数int cols。

//列数int startRow。

//入口行坐标int startCol。

//入口列坐标int endRow。

//出口行坐标int endCol。

//出口列坐标Maze;其中,maze表示迷宫数组,rows和cols表示迷宫的行数和列数,startRow和startCol表示入口的行坐标和列坐标,endRow和endCol表示出口的行坐标和列坐标。

主要算法设计本程序采用非递归的深度优先搜索算法,具体实现如下:1.初始化栈,将起点入栈。

2.取出栈顶元素,判断是否为终点,若是则输出路径,程序结束。

3.若不是终点,则将该点的四个方向依次入栈(若该方向为通路且未被访问过),并标记为已访问。

4.重复2-3步骤,直到栈为空。

测试用例设计测试用例见题集p105.调试报告在编写程序的过程中,遇到了以下问题:1.如何判断一个方向是否为通路?解决方法:在maze数组中,1表示通路,0表示障碍。

迷宫求解

迷宫求解

迷宫求解1、课程设计目的:本设计的主要目的是实现一个以链表作存储结构的栈,然后编写一个求解迷宫的非递归程序。

求得的通路以三元组(i,j,d)的形式输出,其中:(i,j)指示迷宫中的一个坐标,d表示走到下一座标的方向。

2、实验内容及要求:以一个m*n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。

可以输入一个任意大小的迷宫数据,用递归非递归的方法求出一条走出迷宫的路径,并将路径输出,或得出没有路径的结论。

3、实验手段和方法:(1)计算机解迷宫通常用“穷举求解”法。

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

假如所有可能的通路都探索到而未能到达出口,则所设定的迷宫没有通路。

(2)可以二维数组存储迷宫数据,通常设定入口点的下标为(1,1),出口点的下标为(n,n)。

为处理方便起见,可在迷宫的四周加一圈障碍。

对于迷宫中任一位置,均可约定有东、南、西、北四个方向可通。

#include<stdio.h>#include<iostream>#define max 8typedef struct{int row;int column;int *pos;}Array;typedef struct{int row;int colu;int di;}SElem;typedef struct node{SElem data;struct node *next;}*LinkStack;void CreateArray(Array &A,int row,int column){if(row>=max||column>=max) {printf("Error!\n");return;}A.row=row;A.column=column;A.pos=(int*)malloc(row*column*sizeof(int));printf("please input channel(0)or obstacle(1):");for(int i=0;i<A.row;i++)for(int j=0;j<A.column;j++)scanf("%d",&A.pos[i*column+j]);}void InitLStack(LinkStack &S){S=(struct node *)malloc(sizeof(struct node));S->next=NULL;}void PushLStack(LinkStack &S,int i,int j,int x){LinkStack p;SElem e;e.row=i;e.colu=j;e.di=x;p=(LinkStack)malloc(sizeof(struct node));p->data=e;p->next=S;S=p;}void PopLStack(LinkStack &S,SElem &e){LinkStack p;if(S->next==NULL)printf("stack underflow");else{e=S->data;p=S;S=S->next;free(p);}}int Pass(Array A,LinkStack &S,int &curpos,int &i,int &j){ if(curpos!=2){if(j<A.column&&!A.pos[(i-1)*A.column+j]){A.pos[(i-1)*A.column+j-1]=2;PushLStack(S,i,j++,1);if(i==A.row&&j==A.column) return 1;else curpos=A.pos[(i-1)*A.column+j];}else if(i<A.row&&!A.pos[i*A.column+j-1]){A.pos[(i-1)*A.column+j-1]=2;PushLStack(S,i++,j,2);curpos=A.pos[(i-1)*A.column+j-1];}else if(j>2&&!A.pos[(i-1)*A.column+j-2]){A.pos[(i-1)*A.column+j-1]=2;PushLStack(S,i++,j,3);curpos=A.pos[(i-1)*A.column+j-1];}else if(i>2&&!A.pos[(i-2)*A.column+j-1]){A.pos[(i-1)*A.column+j-1]=2;PushLStack(S,i--,j,4);curpos=A.pos[(i-1)*A.column+j-1];}return 1;}return 0;}void MazePath(LinkStack &S,Array A){int curpos=A.pos[1];int i=1,j=1;SElem e;do{if(!Pass(A,S,curpos,i,j)){if(S->next!=NULL){PopLStack(S,e);}}}while(i<A.row||j<A.column);PushLStack(S,A.row,A.column,0);}void DisLStack(LinkStack S){if(S->next==NULL) {printf("stack underflow!\n");return;}while(S->next!=NULL){printf("(%d,%d,%d)\n",S->data.row,S->data.colu,S->data.di);S=S->next;}}void main(){Array A;LinkStack S;int row,column;printf("please input row and column:");scanf("%d%d",&row,&column);CreateArray(A,row,column);InitLStack(S);MazePath(S,A);DisLStack(S);}。

迷宫求解课程设计报告

迷宫求解课程设计报告

江西农业大学数据结构实验报告迷宫求解姓名:邹运学号:20132234目录一、需求分析 (2)二、概要设计 (2)三、详细设计 (4)四、调试分析 (6)五、用户手册 (6)六、测试结果 (6)七、附录 (8)一、需求分析1以二维数组a[ROW][COL]表示迷宫。

数组中以数字1表示障碍,数字0表示通路2,用预先定好的迷宫作为原始迷宫文件3设定的迷宫的路口和出口4若设定的迷宫存在通路,则以‘#’表示障碍,‘*’表示通路打印出来5.本程序只求出一条成功的通路二、概要设计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 Stack2、设定迷宫的抽象数据类型定义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表示通路。

数据结构课程设计迷宫问题求解

数据结构课程设计迷宫问题求解

数据结构课程设计迷宫问题求解正文:1:问题描述迷宫问题是一个经典的问题,其目标是找出从入口到出口的路径。

我们需要设计一个算法,解决给定迷宫的问题。

2:问题分析首先,我们需要通过数据结构来表示迷宫。

可以使用二维数组来表示迷宫的格子,其中0表示可通行的路径,1表示墙壁或障碍物。

3:迷宫求解算法3.1 深度优先搜索算法深度优先搜索算法是一种递归算法,从入口开始,不断地往下搜索,直到找到出口或者搜索完整个迷宫。

在搜索过程中,需要标记已经访问过的格子,以避免重复搜索。

3.2 广度优先搜索算法广度优先搜索算法使用队列来进行搜索,从入口开始,先将入口加入队列中,然后遍历队列中的所有相邻格子,将未访问过的格子加入队列中。

直到找到出口或者队列为空。

3.3 最短路径算法最短路径算法可以使用Dijkstra算法或者A算法。

Dijkstra算法使用了优先队列,通过计算每个格子到入口的距离,选择最短路径。

A算法在计算格子到入口的距离时,还考虑了格子到出口的距离的估算值。

4:程序实现4.1 数据结构设计我们使用二维数组来表示迷宫的格子,使用一个额外的二维数组来标记已访问的格子。

可以使用一个结构体来表示每个格子的坐标。

4.2 算法实现我们需要实现深度优先搜索算法、广度优先搜索算法以及最短路径算法。

可以使用递归来实现深度优先搜索算法,使用队列来实现广度优先搜索算法,使用优先队列来实现最短路径算法。

4.3 界面设计可以使用命令行界面来输入迷宫的大小和格子的类型,以及展示迷宫的解法和最短路径。

5:测试与结果分析我们需要对设计的算法进行测试,并对结果进行分析。

可以创建一些不同大小和复杂度的迷宫,对算法进行测试,并统计算法的时间复杂度和空间复杂度。

6:附件本文档涉及的附件包括程序源代码和测试数据。

7:法律名词及注释7.1 数据结构:指在计算机中组织和存储数据的方式,包括数组、链表、栈、队列等。

7.2 深度优先搜索算法:一种使用递归的搜索算法,从一个节点开始,优先搜索其相邻节点,直到达到目标节点或无法继续搜索为止。

迷宫求解课程设计说明书

迷宫求解课程设计说明书

数据结构课程设计设计说明书迷宫问题求解学生姓名学号班级成绩指导教师计算机科学与技术系2011年 9 月 9 日数据结构课程设计评阅书题目迷宫问题求解学生姓名学号指导教师评语及成绩成绩:教师签名:年月日答辩教师评语及成绩成绩:教师签名:年月日教研室意见总成绩:室主任签名:年月日注:指导教师成绩60%,答辩成绩40%,总成绩合成后按五级制记入。

课程设计任务书2011 —2012 学年第一学期专业:学号:姓名:课程设计名称:数据结构课程设计设计题目:迷宫问题求解完成期限:自 2011 年 8 月 29 日至 2011 年 9 月 9 日共 2 周设计依据、要求及主要内容(可另加附页):输入一个任意大小的迷宫数据,设置入口、出口及障碍,借助栈结构求解走出迷宫的路径并输出。

1.遵循结构化程序设计思想,采用C/C++实现。

2.界面友好,操作简便,容错性。

基本要求如下:1)问题分析和任务定义:根据设计题目的要求,充分地分析和理解问题,明确问题要求做什么?(而不是怎么做?)限制条件是什么?确定问题的输入数据集合。

2)逻辑设计:对问题描述中涉及的操作对象定义相应的数据类型,并按照以数据结构为中心的原则划分模块,定义主程序模块和各抽象数据类型。

逻辑设计的结果应写出每个抽象数据类型的定义(包括数据结构的描述和每个基本操作的功能说明),各个主要模块的算法,并画出模块之间的调用关系图;3)详细设计:定义相应的存储结构。

在这个过程中,要综合考虑系统功能,使得系统结构清晰、合理、简单和易于调试,抽象数据类型的实现尽可能做到数据封装,基本操作的规格说明尽可能明确具体。

详细设计的结果是对数据结构和基本操作做出进一步的求精,写出数据存储结构的类型定义;4)程序编码:把详细设计的结果进一步求精为程序设计语言程序。

同时加入一些注解和断言,使程序中逻辑概念清楚;5)程序调试与测试:能够熟练掌握调试工具的各种功能,设计测试数据确保程序正确。

数据结构课程设计报告—迷宫求解问题

数据结构课程设计报告—迷宫求解问题

课题设计1:迷宫求解一. 需求分析:本程序是利用非递归的方法求出一条走出迷宫的路径,并将路径输出。

首先由用户输入一组二维数组来组成迷宫,确认后程序自动运行,当迷宫有完整路径可以通过时,以0和1所组成的迷宫形式输出,标记所走过的路径结束程序;当迷宫无路径时,提示输入错误结束程序。

二、概要设计:1.抽象数据类型定义:ADT Find{数据对象:D={ai|ai ∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<ai-1,ai>|ai-1, ai∈D }基本操作:find (&S)初始条件:已初始化栈S,且栈为空操作结果:从栈S中找出相对应的数据关系,并输出结果}ADT Find2. 主程序的流程以及各程序模块之间的调用关系:(1).定义变量i、j、w、z为整形变量(2).输入迷宫二维数组maze(0:m,0:n)(3).调用子程序find ()(4).结束程序三、相应的源程序如下:#include<stdio.h>#include<stdlib.h>typedef enum { ERROR, OK } Status;typedef struct{int row, line;}PosType;typedef struct{int di, ord;PosType seat;}SElemType;typedef struct{SElemType * base;SElemType * top;int stacksize;}SqStack;Status InitStack(SqStack &S);Status Push(SqStack &S,SElemType &a);Status Pop(SqStack &S,SElemType &a);Status StackEmpty(SqStack S);Status MazePath(int maze[12][12],SqStack &S, PosType start, PosType end);void Initmaze(int maze[12][12],int size);void printmaze(int maze[12][12],int size);Status Pass(int maze[12][12],PosType CurPos);void Markfoot(int maze[12][12], PosType CurPos);PosType NextPos(PosType CurPos, int Dir);void printpath(int maze[12][12],SqStack S,int size);void main (void){SqStack S;int size,maze[12][12];for(int n=0;n<10;n++){printf("创建一个正方形迷宫,请输入迷宫尺寸(注意不要大于50):\n");scanf("%d",&size);if(size<1 || size>10){printf("输入错误!");return;}Initmaze(maze,size);printmaze(maze,size);PosType start,end;printf("输入入口行坐标和列坐标:");scanf("%d",&start.row);scanf("%d",&start.line);printf("输入出口行坐标和列坐标:");scanf("%d",&end.row);scanf("%d",&end.line);if(MazePath(maze,S,start,end))printpath(maze,S,size);else printf("找不到通路!\n\n");}}Status MazePath(int maze[12][12],SqStack &S, PosType start, PosType end){PosType curpos;int curstep;SElemType e;InitStack(S);curpos = start;curstep = 1;do {if (Pass(maze,curpos)){Markfoot(maze,curpos);e.di =1;e.ord = curstep;e.seat= curpos;Push(S,e);if (curpos.row==end.row && curpos.line==end.line)return OK;curpos = NextPos(curpos, 1);curstep++;}else{if (!StackEmpty(S)){Pop(S,e);while (e.di==4 && !StackEmpty(S)) {Markfoot(maze,e.seat);Pop(S,e);}if (e.di<4){e.di++;Push(S, e);curpos = NextPos(e.seat, e.di);}}}} while (!StackEmpty(S));return ERROR;}void Initmaze(int maze[12][12],int size){char select;printf("选择创建方式A:自动生成B:手动创建\n");label:scanf("%c",&select);if(select=='a'||select=='A'){for(int i=0;i<size+2;i++)maze[0][i]=1;for( i=1;i<size+1;i++){maze[i][0]=1;for(int j=1;j<size+1;j++)maze[i][j]=rand()%2;maze[i][size+1]=1;}for(i=0;i<size+2;i++)maze[size+1][i]=1;}else if(select=='b'||select=='B'){printf("按行输入%d*%d数据,0代表可通,1代表不可通(每行以Enter结束):\n",size,size);for(int i=0;i<size+2;i++)maze[0][i]=1;for( i=1;i<size+1;i++){maze[i][0]=1;for(int j=1;j<size+1;j++)scanf("%d",&maze[i][j]);maze[i][size+1]=1;}for(i=0;i<size+2;i++)maze[size+1][i]=1;}else if(select=='\n')goto label;else printf("输入错误!");}void printmaze(int maze[12][12],int size){printf("\n\n");printf("显示所建的迷宫(#表示外面的墙):\n");for(int i=0;i<size+2;i++)printf("%c ",'#');printf("\n");for(i=1;i<size+1;i++){printf("%c ",'#');for(int j=1;j<size+1;j++){printf("%d ",maze[i][j]);}printf("%c",'#');printf("\n");}for(i=0;i<size+2;i++)printf("%c ",'#');printf("\n");}void printpath(int maze[12][12],SqStack S,int size){printf("\n\n通路路径为:\n");SElemType * p=S.base;while(p!=S.top){maze[p->seat.row][p->seat.line]=2;p++;}for(int i=0;i<size+2;i++)printf("%c ",'#');printf("\n");for(i=1;i<size+1;i++){printf("%c ",'#');for(int j=1;j<size+1;j++){if(maze[i][j]==2) printf("%c ",'0');else printf(" ");}printf("%c",'#');printf("\n");}for(i=0;i<size+2;i++)printf("%c ",'#');printf("\n\n"); }Status Pass(int maze[12][12],PosType CurPos){if (maze[CurPos.row][CurPos.line]==0)return OK;else return ERROR;}void Markfoot(int maze[12][12],PosType CurPos){maze[CurPos.row][CurPos.line]=1;}PosType NextPos(PosType CurPos, int Dir){PosType ReturnPos;switch (Dir){case 1:ReturnPos.row=CurPos.row;ReturnPos.line=CurPos.line+1;break;case 2:ReturnPos.row=CurPos.row+1;ReturnPos.line=CurPos.line;break;case 3:ReturnPos.row=CurPos.row;ReturnPos.line=CurPos.line-1;break;case 4:ReturnPos.row=CurPos.row-1;ReturnPos.line=CurPos.line;break;}return ReturnPos;}Status InitStack(SqStack &S){S.base=(SElemType *)malloc(100*sizeof(SElemType));if(!S.base)return ERROR;S.top=S.base;S.stacksize=100;return OK;}Status Push(SqStack &S,SElemType &a){*S.top++=a;return OK;}Status Pop(SqStack &S,SElemType &a){if(S.top==S.base)return ERROR;a=*--S.top;return OK;}Status StackEmpty(SqStack S){if(S.top==S.base)return OK;return ERROR;}以下为测试数据:输入一个矩阵,例如:1 0 0 1 10 0 1 1 11 0 0 0 10 1 0 1 11 1 0 0 0输入入口行坐标和列坐标:1 2输入出口行坐标和列坐标:5 5通路路径为:课题设计3:joseph环一. 需求分析:利用单向循环链表存储结构模拟此过程,按照出列的顺序输出各个人的编号。

任务书1(迷宫问题)

任务书1(迷宫问题)

课程设计报告课程名称数据结构课程设计课题名称迷宫问题专业班级学号姓名指导教师刘洞波陈华光陈多2013年6月15日课程设计任务书课程名称数据结构课程设计课题迷宫问题专业班级学生姓名学号指导老师审批任务书下达日期:2013年6月16日任务完成日期:2013年6月22日一、设计内容与设计要求1.设计内容:1)问题描述以一个M*N的长方阵表示迷宫,0和1分别表示迷宫中的通路和墙壁。

设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出米有通路的结论。

2)基本要求a.实现一个以链表作存储结构的栈类型,然后编写一个求解迷宫的非递归程序。

求得的通路以三元组(i,j,d)的形式输出,其中:(i,j)指示迷宫中的一个坐标,d表示走到下一个坐标的方向。

b.编写递归形式的算法,求得迷宫中所有可能的通路。

3)测试数据迷宫的测试数据如下:左上角(1,1)为入口,右下角(8,9)为出口。

4计算机解迷宫通常用的是“穷举求解”方法,即从入口出发,顺着某一个方向进行探索,若能走通,则继续往前进;否则,沿着原路退回,换一个方向继续探索,直至出口位置,求得一条通路。

假如所有可能的通路都探索到而未能到达出口,则设定的迷宫没有通路。

可以二维数组存储迷宫数据,通常设定入口点的下标为(1,1),出口点的下标为(m,n)。

为处理方便起见,可在迷宫的四周加一圈障碍。

对于迷宫中任一位置,均可约定有东、南、西、北四个方向可通。

2.设计要求:●课程设计报告规范1)需求分析a.程序的功能。

b.输入输出的要求。

2)概要设计a.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块的功能。

b.课题涉及的数据结构和数据库结构;即要存储什么数据,这些数据是什么样的结构,它们之间有什么关系等。

3)详细设计a.采用C语言定义相关的数据类型。

b.写出各模块的类C码算法。

c.画出各函数的调用关系图、主要函数的流程图。

4)调试分析以及设计体会a.测试数据:准备典型的测试数据和测试方案,包括正确的输入及输出结果和含有错误的输入及输出结果。

迷宫求解

迷宫求解

迷宫求解一.需求分析:(1)以二维数组Maze [m+1][n+1]表示迷宫,其中:Maze[0][0]和Maze[m+1][0]及Maze[0][n+1]和Maze[m+1][n+1]为添加的障碍,不予显示。

数组中以元素值为0表示通路,1表示障碍。

(2)根据用户的需要,动态开辟迷宫的行数、列数。

(3)迷宫的出入口由用户自己确定。

(4)由随机函数产生的迷宫若存在通路,则给出提示“以找到一条路径”,并给出此路径(第i步:点(p,q)格式),并给出演示算法:用箭头表示行走的路径。

(5)测试数据:输入迷宫的行数为10和列数为15,输出为:(见下图)二.概要设计设计栈的抽象结构类型定义int M,N;//迷宫的大小typedef int MazeType[100][100]; //用较大的数100,最外凿初始化成墙,实际含M,N个格子typedef int Status;typedef int ElemType; //迷宫数组中的元素类型#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{int x;int y;}PosType;//坐标的位置typedef struct{int ord;PosType seat;int di;}SElemType;//栈中元素类型typedef struct{SElemType *base;SElemType *top;int stacksize;}Stack;//栈类型具体函数如下:Status InitStack(Stack &S)//构造空栈SStatus Push(Stack &S, SElemType e)//插入e为栈顶元素Status Pop(Stack &S,SElemType &e)//栈顶元素出栈并用e带回其值Status GetTop(Stack S,SElemType &e)//取出栈顶元素Status StackEmpty(Stack S)//判空Status StackTraverse(Stack S,Status (*visit)(SElemType))//访问栈中元素Status PrintSElem(SElemType e)Status MakeMaze(MazeType &maze,int M,int N)//生成迷宫,"1或2"表示通PATH1或PATH2,"0"表示不通W ALLvoid PrintMaze(MazeType maze)//输出迷宫三.详细设计1.坐标位置类型typedef struct{int x;int y;}PosType;//坐标的位置2.栈类型typedef struct{SElemType *base;SElemType *top;int stacksize;}Stack;//栈类型3.把元素压入栈里Status Push(Stack &S, SElemType e)//插入e为栈顶元素{if(S.top-S.base>=S.stacksize){S.base=(SElemType *) realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S.base) exit(OVERFLOW);S.top=(S.base+S.stacksize);S.stacksize+=STACK_INIT_SIZE;}*S.top++=e; //top指向待插入位置return OK;}4访问栈中元素Status StackTraverse(Stack S,Status (*visit)(SElemType))//访问栈中元素{SElemType *p=S.base;if(S.base==S.top)printf("空栈\n");elsewhile(p<S.top){(*visit)(*p);++p;}return OK;}5.迷宫的自动生成Status MakeMaze(MazeType &maze,int M,int N)//生成迷宫,"1或2"表示通PATH1或PATH2,"0"表示不通W ALL{PosType m;srand(time(NULL));for(m.y=0;m.y<=N-1;m.y++){maze[0][m.y]=BOUNDARY;maze[M-1][m.y]=BOUNDARY;}for(m.x=1;m.x<=N-2;m.x++){maze[m.x][0]=BOUNDARY;maze[m.x][N-1]=BOUNDARY;}for(m.x=1;m.x<=M-2;m.x++)for(m.y=1;m.y<=N-2;m.y++)maze[m.x][m.y]=rand()%4;//产生随机数0,1,2,3,墙与非墙1:3 return OK;}6.探索路径可通过if(maze[curpos.x][curpos.y]==PA TH1 || maze[curpos.x][curpos.y]==PA TH2 ||maze[curpos.x][curpos.y]==PATH3)//当前位置可通{e.ord=curstep;e.seat=curpos;e.di=1;//当前位置加入路径Push(S,e);if(curpos.x==end.x && curpos.y==end.y)//当前位置就是终点{maze[curpos.x][curpos.y]=DESTINATION;return OK;}else{maze[curpos.x][curpos.y]=RIGHT;//从其向右走curpos=Nextpos(curpos,1);//下一位置是右边curstep++;}}7.探索下一步操作PosType Nextpos(PosType position,ElemType direction){PosType curdir;//当前位置curdir=position;switch (direction){case 1:curdir.y++;break;case 2:curdir.x++;break;case 3:curdir.y--;break;case 4:curdir.x--;break;}return curdir;}四.测试结果自行设置的迷宫行数为10,列数为15,得到迷宫如下:此迷宫可用,输入非零数10有:设置入口为(1,1),出口为(10,15)得到图形如下:五.结果分析与总结本程序设计符合题目要求,实现了寻找到一条通路,可以从刚开始探索到目标点(10,15),运用了栈的相关知识对迷宫进行求解。

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

数据结构课程设计设计说明书迷宫问题的求解学生姓名学号班级成绩指导教师计算机科学与技术系2010年9月10日数据结构课程设计评阅书题目迷宫问题的求解学生姓名学号指导教师评语及成绩成绩:教师签名:年月日答辩教师评语及成绩成绩:教师签名:年月日教研室意见总成绩:室主任签名:年月日注:指导教师成绩60%,答辩成绩40%,总成绩合成后按五级制记入。

课程设计任务书2010—2011学年第一学期专业:计算机科学与技术学号:姓名:课程设计名称:数据结构课程设计设计题目:迷宫问题的求解完成期限:自2010 年08 月30 日至2010 年09 月12 日共 2 周设计内容:用C/C++设计一个计算机程序对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

设计要求:1)问题分析和任务定义:根据设计题目的要求,充分地分析和理解问题,明确问题要求做什么?(而不是怎么做?)限制条件是什么?确定问题的输入数据集合。

2)逻辑设计:对问题描述中涉及的操作对象定义相应的数据类型,并按照以数据结构为中心的原则划分模块,定义主程序模块和各抽象数据类型。

逻辑设计的结果应写出每个抽象数据类型的定义(包括数据结构的描述和每个基本操作的功能说明),各个主要模块的算法,并画出模块之间的调用关系图;3)详细设计:定义相应的存储结构并写出各函数的伪码算法。

在这个过程中,要综合考虑系统功能,使得系统结构清晰、合理、简单和易于调试,抽象数据类型的实现尽可能做到数据封装,基本操作的规格说明尽可能明确具体。

详细设计的结果是对数据结构和基本操作做出进一步的求精,写出数据存储结构的类型定义,写出函数形式的算法框架;4)程序编码:把详细设计的结果进一步求精为程序设计语言程序。

同时加入一些注解和断言,使程序中逻辑概念清楚;5)程序调试与测试:采用自底向上,分模块进行,即先调试低层函数。

能够熟练掌握调试工具的各种功能,设计测试数据确定疑点,通过修改程序来证实它或绕过它。

调试正确后,认真整理源程序及其注释,形成格式和风格良好的源程序清单和结果;6)结果分析:程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。

算法的时间、空间复杂性分析;7)编写课程设计报告;以上要求中前三个阶段的任务完成后,先将设计说明书的草稿交指导老师面审,审查合格后方可进入后续阶段的工作。

设计工作结束后,经指导老师验收合格后将设计说明书打印装订,并进行答辩。

指导教师(签字):教研室主任(签字):批准日期:年月日摘要设计了一个计算机程序对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

该程序按照以数据结构为中心的原则划分模块,定义主程序模块和各抽象数据类型,主程序包括构造一个空栈(InitStack)、设计迷宫(MakeMaze)、寻找迷宫路径(MazePath)、输出迷宫(Print)等模块。

本程序采用VC++作为软件开发环境,采用了栈、结构体、数组来实现。

操作简单,容易理解。

关键词:迷宫;栈;数据结构目录1 课题描述 (1)2问题分析 (2)3 主要算法和流程图 (3)3.1 主要算法 (3)3.2 流程图 (4)4 程序源代码 (8)5运行结果 (13)6 总结 (15)参考文献 (16)1 课题描述迷宫问题的求解通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前探索,若能走通,则继续往前走;否则沿原路退回,换另一个方向再继续探索,直至所有可能的通路都探索到为止。

因此,在求迷宫通路的算法中需要一个后进先出的结构——“栈”。

在迷宫求解问题的程序设计中求出一条从入口到出口的通路,或得出没有通路的结论。

假设“当前位置”指的是“在搜索过程中某一时刻所在图中某个方块位置”,则求迷宫中一条路径的算法的基本思想是:若当前位置“可通”,则纳入“当前路径”,并继续朝“下一位置”探索,即切换“下一位置”为“当前位置”,如此重复直至到达出口;若当前位置“不可通”,则应顺着“来向”退回到“前一通道块”,然后朝着除“来向”之外的其他方向继续探索;若该通道块的四周四个方块均“不可通”,则应从“当前路径”上删除该通道块。

所谓“下一位置”指的是“当前位置”四周四个方向(东、南、西、北)上相邻的方块。

由此,“纳入路径”的操作即为“当前位置入栈”;“从当前路径上删除前一通道块”的操作即为“出栈”。

迷宫问题的求解以Visual C++6.0作为开发工具。

2问题分析迷宫问题的求解主要应用栈,栈的基本操作除了在栈顶插入或删除外,还有栈的初始化、判空及取栈顶元素等。

栈的数据元素类型在应用程序内定义,并称插入元素的操作为入栈,删除栈顶元素的操作为出栈。

本设计采用栈、结构体、数组实现迷宫问题的求解,主程序中包括初始化栈(InitStack)、入栈(PushStack)、出栈(PopStack)、留下足迹(FootPrint)、探索方向(NextPos)、判断足迹是否走过(Pass)、判断栈是否空(StackEmpty)、留下不能通过的标记(MarkPrint)、设计迷宫(MakeMaze)、寻找迷宫路径(MazePath)以及输出迷宫(Print)。

程序设计中用到了if-else选择语句、if选择语句、switch控制语句、for循环语句、do-while循环语句以及while循环语句。

3 主要算法和流程图3.1 主要算法求迷宫中一条从入口到出口的路径的算法可简单描述如下:设定当前位置的初值为入口位置;do{若当前位置可通,则{将当前位置插入栈顶; //纳入路径若该位置是出口位置,则结束; //求得路径存放在栈中否则切换当前位置的东邻块为新的当前位置;}否则,若栈不空且栈顶位置尚有其他方向未经探索,则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块;若栈不空但栈顶位置的四周均不可通;则{删去栈顶位置; //从路径中删去该通道块若栈不空,则重新测试新的栈顶位置,直至找到一个可通的相邻块或出栈至栈空;}3.2 流程图本设计采用栈、结构体、数组实现迷宫问题的求解。

下面给出迷宫问题的求解程序中下一步的探索方向(NextPos)、设计迷宫(MakeMaze)、寻找迷宫路径(MazePath)以及输出迷宫(Print)的流程图。

其中图3.2.1为下一步的探索方向(NextPos)的流程图:开始sit &c,intdir,sit C;dir==1; dir==2; dir==3; dir==4;C.seatx=c.seatx;C.seaty=c.seaty+1;C.seatx=c.seatx+1;C.seaty=c.seaty;C.seatx=c.seatx;C.seaty=c.seaty-1;C.seatx=c.seatx-1;C.seaty=c.seaty;return C;结束Y Y Y YNNNN图3.2.1下一步的探索方向(NextPos)的流程图图3.2.2为设计迷宫(MakeMaze )的流程图:图3.2.2设计迷宫(MakeMaze )的流程图开始int i,j;输入一个M*M 的迷宫i=0;i<M;j=0;j<M;输入Maze[i][j];j++;i++;调用Print 函数;结束NNY Y图3.2.3为寻找迷宫路径(MazePath )的流程图:开始Stack S;finds e;sit start,end,curpos;int curstep;调用函数InitStack;调用函数(Pass(curpos);调用函数FootPrint(curpos);留下足迹调用函数PushStack(S,e);加入路径curpos==end;探索下一步!StackEmpty(S);调用函数PopStack(S,e);e.di==4&&!StackEmpty(S);留下不能通过的标记,并退回一步e.di<4;e.di++;换下一个方向探索;存在路径,到达终点结束!StackEmpty(S);YNNYNYNYNYYN不存在路径图3.2.3寻找迷宫路径(MazePath )的流程图图3.2.4为输出迷宫(Print )的流程图:开始int i,j;i=0;i<M;j=0:j<M;Maze[i][j]==0;Maze[i][j]==1;Maze[i][j]==2;Maze[i][j]==3;标记" "标记"■"标记"×"标记"㊣"j++;i++;结束Y Y Y Y N N N NY Y NN图3.2.4输出迷宫(Print )的流程图4 程序源代码#include<stdlib.h> //引用库函数#include<stdio.h>#define STACK_INIT_SIZE 300#define STACKINCREMENT 20#define M 10 //迷宫的最大坐标typedef int MazeType[M][M];typedef struct{int seatx;int seaty;}sit; //迷宫坐标typedef struct{int ord;sit seat;int di; //从此通道块走向下一通道块的方向}finds; //0:无效,1:东,2:南,3:西,4:北typedef struct{finds *base;finds *top;int stacksize;}Stack;MazeType Maze;sit start,end; //start,end入口和出口的坐标int InitStack(Stack &S) //构造一个空栈{S.base=(finds*)malloc(STACK_INIT_SIZE*sizeof(finds));if(!S.base)exit(1);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return 1;}void Print(){ //输出迷宫int i,j;for(i=0;i<M;i++){for(j=0;j<M;j++){if(Maze[i][j]==0)printf(" ");else if(Maze[i][j]==1)printf("■");else if(Maze[i][j]==3)printf("×");else if(Maze[i][j]==2)printf("㊣");}printf("\n");}}void MakeMaze(){ //设计迷宫int i,j;printf("\n======================欢迎进入迷宫游戏======================\n");printf("\n 说明:由玩家输入一个迷宫,系统会在很短时间内判断出行走路径!\n");printf("\n\t\t\t祝您游戏愉快!\n");printf("\n======================Good Luck To You======================\n");printf("\n===>请设计一个迷宫<===\n");printf("\n输入一个 %d * %d 的迷宫【包括外墙】:\n",M,M);for(i=0;i<M;i++)for(j=0;j<M;j++)scanf("%d",&Maze[i][j]);printf("\n");printf("迷宫结构如下:\n");Print();}void PushStack(Stack &S,finds e){ //增加栈顶if(S.top-S.base>=S.stacksize){S.base=(finds*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(fin ds));if(!S.base)exit(1);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;}int PopStack(Stack &S,finds &e){ //删除栈顶if(S.top==S.base)return 0;e=*--S.top;return 1;}void FootPrint(sit s){//走过的路经留下足迹,也就是将坐标值为非零Maze[s.seatx][s.seaty]=2;}sit NextPos(sit &c,int dir){ //规定下一步试探的方向sit C;switch(dir){case 1:C.seatx=c.seatx;C.seaty=c.seaty+1;break;case 2:C.seatx=c.seatx+1;C.seaty=c.seaty;break;case 3:C.seatx=c.seatx;C.seaty=c.seaty-1;break;case 4:C.seatx=c.seatx-1;C.seaty=c.seaty;break;}return C;}int Pass(sit a){ //判断该足迹是否走过,走过为1否则为0,进行下一步试探if(Maze[a.seatx][a.seaty]==0)return 1;else return 0;}int StackEmpty(Stack &S) { //判断栈是否为空,如果为空则返回1,否则返回0if(S.top==S.base) return 1;else return 0;}int MarkPrint(sit b){ //留下不能通过的标记Maze[b.seatx][b.seaty]=3;return 1;}int MazePath(sit start,sit end){ //若迷宫maze中存在从入口start到出口end的通道,则求的一条存放在栈中(从栈底到栈顶)Stack S;finds e; //栈元素sit curpos; //当前位置int curstep=1;InitStack(S);curpos=start; //设定“当前位置”为“入口位置”do{if(Pass(curpos)){//当前位置可以通过,即是未曾走到过的通道块FootPrint(curpos); //留下足迹e.di=1;e.ord=curstep;e.seat=curpos;PushStack(S,e); //加入路径if(curpos.seatx==end.seatx&&curpos.seaty==end.seaty){printf("\n此迷宫存在通道:\n");return 1; //到达终点(出口)}curpos=NextPos(curpos,1); //下一个位置是当前位置的东邻curstep++; //探索下一步}//ifelse{ //当前位置不能通过if(!StackEmpty(S)){PopStack(S,e);while(e.di==4&&!StackEmpty(S)){MarkPrint(e.seat);PopStack(S,e); //留下不能通过的标记,并退回一步} //whileif(e.di<4){e.di++;PushStack(S,e); //换下一个方向探索curpos=NextPos(e.seat,e.di); //设定当前位置是该新方向上的相邻块}//if}//if}//else}while(!StackEmpty(S));printf("\n此迷宫不存在通道!\n");return 0;}void main(){ //主函数MakeMaze();printf("\n请输入入口的横坐标,纵坐标(用逗号隔开): ");scanf("%d,%d",&start.seatx,&start.seaty);printf("\n请输入出口的横坐标,纵坐标(用逗号隔开): ");scanf("%d,%d",&end.seatx,&end.seaty);MazePath(start,end);Print();printf("\n==========感谢您的使用,程序退出!==========\n"); }5运行结果按要求输入迷宫,若存在从入口到出口的通路,运行结果如图5.1所示:图5.1 存在从入口到出口的通路不存在从入口到出口的通路,运行结果如图5.2所示:图5.2不存在从入口到出口的通路6 总结课程设计的过程是非常不容易的,但对我却有很大的启发。

相关文档
最新文档