用栈实现迷宫求解和数制转化软件
栈的迷宫求解(数据结构试验)
实验二：迷宫问题班级：姓名：学号：一、需求分析（1 ）以二维数据Maze[m+2][n+2] 表示迷宫，其中：Maze[0][j] 和Maze[m+1][j]（0<=j<=n+1）及Maze[i][0]和Maze[i][n+1](0<=i<=m+1)为添加一圈障碍。
数组中以元素值为0 表示通路，1 表示障碍，限定迷宫的大小m,n<=100。
（2）用户输入迷宫的规模m,n；并按照此规模输入迷宫的具体数据。
（3）迷宫的入口位置和出口位置可由用户随时设定。
（4）若设定的迷宫存在通路，则以长方阵形式将迷宫及其通路输出到标准输出文件（即终端）上，其中，字符“#”表示障碍，字符“*”表示路径上的位置，字符“@”表示“死胡同”，即曾途径然而不能到达出口的位置，余者用空格符印出。
若设定的迷宫不存在通路，则报告相应信息。
（5）本程序只求出一条成功的通路。
然而，只需要对迷宫求解的函数作小量修改，便可求得全部路径。
（6）测试数据见原题，当入口位置为（1，1），出口位置为（9，8）时，输出数据应为：* * # @ @ @ #* # @ @ @ #* * @ @ # # #* # # # # @* * * # * * * @# * * * # * ## # # # * ## # # * ## # * *（7）程序执行的命令为：1）创建迷宫；2）求解迷宫；3）输出迷宫的解。
二、概要设计1. 设定栈的抽象数据类型定义：ADT Stack{数据对象：D={a i|a i∈CharSet,i=1,2,…,n,n>=0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…,n}基本操作：InitStack(&S)操作结果：构造一个空栈S。
DestroyStack（&S）初始条件：栈S 已存在。
操作结果：销毁栈S。
ClearStack(&S)初始条件：栈S 已存在。
利用栈实现迷宫游戏的求解
Κ7 <
βΩ Ο
?
即)
2
Υ 〕二 , Τ
_
φ
Φ Φ
前 一 点并且 继 续从 下一 个 方 向 向前试 探
达 的各 点 的坐 标
+ , ,
我 们可 以使用 栈来 存放 所 能够 到
因此
,
达 的每 一 点的 下 标 及从 该 点 前进 的方 向
栈 中存 放 的不仅 是 顺序 到
。
Ν Η
& ) 叩
,
如 当 前点 的 坐 标
&见 图
娜, ? 径茸法实班
=
7 ΩΞ Μ Π; Ο Π 9
Α
。
与 其相 邻 的5 个 点 的坐标 都 可 根据 与 该点 的相 邻 方位 而 得 到
ΩΩ
ΠΜ& 7 Π Ν
7
9 6
: ;
0 < < Κ5ΚΝ Π ] &
_
,
7
6
,
7 Ν
Π
7
,
ΨΟ 9 Π
,
;
Ζ色
[
Β > & = Α
& 5
从
Δ Ω⊥ 7 Θ+ Η
Ε
Φ 搜索 5 个 方 向的邻 Φ
首先探 测 正 东方 向
, ,
没 有通 路
,
接点 [
7 ΩΟ
且 未 走过
即表示 某 处可 以到达
,
,
这样便 到达 新点 继 续 依次探测 此新 点
,
,
即
;
7
ΩΟ + β >
的5 个方 向
若 某 点的所 有 的方 向均 没有通 路
《数据结构》上机实验报告—利用栈实现迷宫求解
SElemType* base;//栈基址,构造前销毁后为空
SElemType* top;//栈顶
int stackSize; //栈容量
}Stack; //栈类型
Status InitStack(Stack &S){ //构造空栈s
S.base=(SElemType*)malloc(INIT_SIZE *sizeof(SElemType));
Stack S;
PostType curpos;
int curstep;//当前序号
SElemType e;
InitStack(S);
InitStack(Path);
curpos=start; //设置"当前位置"为"入口位置"
curstep=1; //探索第一步
do{
if(Pass(maze,curpos)){//当前位置可以通过,即是未曾走到过的通道
福州大学数计学院
《数据结构》上机实验报告
专业和班级：信息计算科学与应用数学6班
学号
姓名
成绩
实验名称
栈、队列
实验内容
利用栈实现迷宫求解
实
验
目
的
和
要
求
【实验目的】
应用栈结构来解决应用问题，加深对栈结构特点的认识和应用。
【基本要求】
首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如:对于下列数据的迷宫，输出的一条通路为;(1,1,1),(1,2,2),(2,2,2),(3,2,3),(3,1,2),....
数据结构_迷宫求解_实验报告 北邮
数据结构实验报告实验名称：实验二——利用栈结构实现迷宫求解问题学生姓名：班级：班内序号：学号：日期：2012年11月19日一、实验目的1、进一步掌握指针、模板类、异常处理的使用2、掌握栈的操作的实现方法3、掌握队列的操作的实现方法4、学习使用栈解决实际问题的能力5、学习使用队列解决实际问题的能力二、实验要求：利用栈结构实现迷宫求解问题。
迷宫求解问题如下：心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫，迷宫中设置很多隔壁，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口，测试算法的迷宫如下图所示。
提示：1、可以使用递归或非递归两种方法实现2、老鼠能够记住已经走过的路，不会反复走重复的路径3、可以自己任意设置迷宫的大小和障碍4、使用“穷举求解”的方法三、程序分析1、存储结构栈存储结构；示意图；2、关键算法分析A、绘制迷宫；伪代码：1、输出迷宫的大小及全部设置为障碍；2、根据键盘的输入绘制迷宫的路线，起始点和终点；void draw()//绘制迷宫障碍{k=getch();switch(int(k)){case 105://上if(by>5){by--;j--;}break;case 107://下if(by<M+4){by++;j++;}break;case 106://左if(bx>2){bx=bx-2;i--;}break;case 108://右if(bx<2*N){bx=bx+2;i++;}break;case 114://'R'路map[i][j]=0;cout<<".";break;case 119://'W'墙map[i][j]=-3;cout<<"■";break;case 115://'S'起点s[0].x=i;//起点入栈s[0].y=j;top=1;map[i][j]=-1;cout<<k;break;case 101://'E'终点map[i][j]=-2;cout<<k;break;}gotoxy(bx,by);}B、路径寻找伪代码；1、向某一方向查找是否有路；2、如有遍历一下栈，看是否已经进栈，一进栈就舍弃，寻求下一个；无就让其进栈。
数据结构栈的应用（迷宫求解）
数据结构栈的应用（迷宫求解）栈的应用迷宫求解任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；源代码：#include#include/*数据定义*/typedefenum { ERROR, OK } Status;typedefstruct{int row; //row表示"行"号int line; //line表示"列"号}PosType; //位置的元素类型typedefstruct{intord; //该通道在路径上的"序号"PosType seat; //通道块在迷宫中的"坐标位置"int di; //从此通道走向下以通道块的"方向"}SElemType; //栈的元素类型typedefstruct{SElemType * base;SElemType * top;intstacksize;}SqStack;/*函数原型说明*/Status InitStack(SqStack&S); //创建一个空栈SStatus Push(SqStack&S,SElemType&a); //插入新元素aStatus Pop(SqStack&S,SElemType&a); //删除栈顶元素，a返回其值Status StackEmpty(SqStack S); //检查是否空栈Status MazePath(int maze[12][12],SqStack&S, PosType start, PosType end); //找通路void Initmaze(int maze[12][12],intx,int y); //初始化迷宫void printmaze(int maze[12][12],intx,int y); //显示迷宫Status Pass(int maze[12][12],PosTypeCurPos); //判断当前位置是否可通void Markfoot(int maze[12][12], PosTypeCurPos); //标记当前位置不可通PosTypeNextPos(PosTy peCurPos, intDir); //进入下一位置void printpath(int maze[12][12],SqStackS,intx,inty,PosTypestart,PosType end); //显示通路/*主函数*/void main (void){PosTypestart,end;int t=0;SqStack S;int maze[12][12];do{if(t!=0)printf("\n");for(int i=0;i<20;i++){printf("* ");}if(t==0){printf("\n*\t欢迎来到迷宫世界\t * \n"); printf("*\t 1.设置迷宫\t\t * \n");}else{printf("\n* 请继续选择：\t\t\t * \n");printf("*\t 1.设置迷宫\t\t * \n");}printf("*\t 2.设置迷宫路径\t\t * \n");printf("*\t 3.输出迷宫通路路径\t * \n"); printf("*\t 4.结束\t\t\t *\n");t++;for(int j=0;j<20;j++){printf("* ");}printf("\n");int s;printf("请选择：");scanf("%d",&s);intaa;intx,y;switch(s){case 1://1.初始化迷宫aa=1;printf("迷宫设置：请输入\n"); //设置迷宫大小do{printf("行X(x<10)=");scanf("%d",&x);printf("列Y(y<10)=");scanf("%d",&y);if(x<1 || x>10||y<1 || y>10){printf("输入错误!\n");}}while(x<1 || x>10||y<1 || y>10);Initmaze(maze,x,y); //初始化迷宫printmaze(maze,x,y); //显示所创建的迷宫break;case 2://寻找迷宫路径if(aa==1){aa=2; //设置入口和出口do{printf("输入入口行坐标:");scanf("%d",&start.row); if(start.row>x)printf("输入错误!\n");}while(start.row>x);do{printf("输入入口列坐标:");scanf("%d",&start.line); if(start.line>y)printf("输入错误!\n");}while(start.line>y);do{printf("输入出口行坐标:");scanf("%d",&end.row); if(end.row>x)printf("输入错误!\n");}while(end.row>x);do{printf("输入出口列坐标:");scanf("%d",&end.line);if(end.line>y)printf("输入错误!\n");}while(end.line>y);}elseprintf("请先初始化迷宫！\n");printf("\n所设置入口坐标为(%d,%d),出口坐标为(%d,%d).\n",start.row,start.line,end.row,end.line);break;case 3://输出此迷宫通路路径if(aa==2){aa=3;if(MazePath(maze,S,start,end)) //若有通路，显示通路printpath(maze,S,x,y,start,end);elseprintf("\n抱歉，找不到通路!\n\n");elseprintf("请先初始化迷宫并寻找路径！\n");break;case 4:exit(0);break;default:exit(0);}}while(1);}/*若迷宫maze中从入口start到出口end的通道，则求得一条存放在栈中*/Status MazePath(int maze[12][12],SqStack&S, PosType start, PosType end){PosTypecurpos;intcurstep;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;}/*初始化迷宫时间复杂度：n^2*/voidInitmaze(int maze[12][12],intx,int y){char select;do{printf("创建方式A:自动生成B:手动创建\n");label: s canf("%c",&select);if(select=='a'||select=='A') //自动生成{for(int i=1;i<x+1;i++)< p="">{for(int j=1;j<y+1;j++)< p="">maze[i][j]=rand()%2;}break;}else if(select=='b'||select=='B') //手动设置{printf("按行输入%d*%d数据,0代表可通,1代表不可通(每行以Enter结束):\n",x,y);for(int i=1;i<x+1;i++)< p="">{for(int j=1;j<y+1;j++)< p="">scanf("%d",&maze[i][j]);maze[i][y+1]=1;}for(i=0;i< p="">break;}else if(select=='\n')goto label; //排除Enter键的影响elseif(select!='b'||select!='B'||select!='a'||select!='A')printf("输入错误!\n");}while(select!='b'||select!='B'||select!='a'||select!='A');}/*显示迷宫时间复杂度：n^2*/voidprintmaze(int maze[12][12],intx,int y){printf("\n\n");printf("显示所建的迷宫(#表示墙):\n");printf("%c ",'#');printf("%c ",'y');for(int j=1;j<y+1;j++)< p="">printf("%d ",j);printf("%c ",'#');printf("\nx ");for(int i=1;i<y+3;i++)< p=""> printf("%c ",'#');printf("\n");for(i=1;i<x+1;i++)< p=""> {if(i<x+1)< p="">printf("%d ",i);elseprintf("%c ",'#');printf("%c ",'#');for(int j=1;j<y+1;j++)< p=""> {printf("%d ",maze[i][j]);}printf("%c",'#');printf("\n");}for(i=0;i</y+1;j++)<></x+1)<></x+1;i++)<></y+3;i++)<></y+1;j++)<><></y+1;j++)<></x+1;i++)<></y+1;j++)<></x+1;i++)<>。
栈在迷宫求解问题中的应用
实验二栈在迷宫求解问题中的应用实验项目中文名称：栈在迷宫求解问题中的应用实验项目英文名称：Application of Stack for Solving MazeProblem实验学时：2 学时、实验目的1、掌握栈的综合应用。
2、掌握迷宫求解的基本算法。
、实验内容1、编写函数，构造一个栈；2、编写函数，实现压栈操作；3、编写函数，实现弹栈操作；4、编写函数，销毁一个栈；5、编写函数，求解迷宫；6、编写函数，展示迷宫的解路径；、设计概要1、核心数据结构1）数据类型：链栈2）定义方法：定义栈顶和栈底指针以及栈容量typedef struct sqstack{ ElemType *bottom;/* 栈不存在时值为NULL */ ElemType *top; /* 栈顶指针*/int stacksize ; /* 当前栈容量，以元素为单位*/ }SqStack ;3）链栈的结构示意图2、程序框架结构与流程图（1）程序模块：·迷宫生产模块：手动生成迷宫。
·判断结点存在：防止结点的重复访问。
·路径查找模块：实现通路的查找，返回一条通路。
·路径输出模块：实现路径以题意要求输出。
（2）程序框架图流程图：3、细节设计（1）坐标位置类型：typedef struct{ int row; // 迷宫中的行int col; // 的列}PosType;// 坐标 (2)迷宫类型：typedef struct{ int m,n;int arr[RANGE][RANGE];}MazeType; // 迷宫类型co void InitMaze(MazeType &maze, int a[][COL], int row, int l)\// 设置迷宫的初值，包括边缘一圈的值Bool MazePath(MazeType &maze,PosType start, PosType end) // 求解迷宫maze中，从入口start 到出口end 的一条路径// 若存在，则返回true ，否则返回false Void PrintMaze ( MazeTypemaze)我的手机2018/12/519:00:05// 将迷宫打印出来（3）栈类型：typedef struct{int step;// 当前位置在路径上的" 序号PosType seat; //当前的坐标位置DirectiveType di;// 往下一个坐标位置的方向}SElemType;// 栈的元素类型typedef struct{SElemType *base;SElemType *top; int stacksize;}SqStack;四、程序源代码#include<stdio.h> #include<stdlib.h>#define SIZE 20#define ERROR 0#define OK 1typedef struct{int row,col;}PosType;typedef struct{int ord;PosType seat;int di;} Elemtype;typedef int Statu;typedef struct stacknode{Elemtype data;struct stacknode* next;}SNode;typedef struct LinkStack{SNode *top, *bottom;}LinkStack;Statu LinkStackInit(LinkStack *S){ //这里编写代码，初始化链栈SNode *a;a=(SNode*)malloc(sizeof(SNode)); S->bottom=a;S->top=a;S->top->next=NULL; return OK;}Statu LinkStackEmpty(LinkStack S){return S.bottom == S.top ? OK:ERROR; }Statu LinkStackPop(LinkStack *S, Elemtype *e){ //这里编写代码，弹栈SNode *b; b=S->top->next; S->top->next=b->next; free(b);return 0;}Statu LinkStackPush(LinkStack *S,Elemtype e){ //这里编写代码，压栈SNode *a; a=(SNode*)malloc(sizeof(SNode)); a->next=S->top->next; a->data=e;S->top->next=a;return 0;Statu LinkStackDestroy(LinkStack *S){ //这里编写代码，销毁栈SNode *a;a=(SNode*)malloc(sizeof(SNode)); while(S->top!=NULL){ a=S->top; S->top=S->top->next; free(a);} return 0;}Statu readmaze(char map[SIZE][SIZE], int *row, int *col){ int i,j; FILE *fp;fp = fopen("maze.txt","r"); fscanf(fp,"%d%*c",row); fscanf(fp,"%d%*c",col);for(i = 0; i < *row; i++){ for(j = 0; j < *col; j++){ map[i][j] = fgetc(fp);} fgetc(fp);} fclose(fp); return OK;}void showmap(char map[SIZE][SIZE], int row, int col){ int i,j;for(i = 0; i < row; i++){ for(j = 0; j<col; j++){ printf("%c ",map[i][j]);} printf("\n");}}void showpath(LinkStack path){ //这里编写代码，输出走出迷宫的路径int i,j,tag;char m[SIZE][SIZE];int row1,col1;FILE *fp1;fp1 = fopen("maze.txt","r");fscanf(fp1,"%d%*c",&row1); fscanf(fp1,"%d%*c",&col1);for(i = 0; i < row1; i++){for(j = 0; j < col1; j++){m[i][j] = fgetc(fp1);}fgetc(fp1);}fclose(fp1);SNode *c;for(i = 0; i < row1; i++){for(j = 0; j<col1; j++){c=path.top->next->next;tag=0;while(c!=NULL){ if(c->data.seat.row==i&&c->data.seat.col==j) {if(c->data.di==1)printf(" ↓ ");if(c->data.di==2) printf(" → ");if(c->data.di==3) printf(" ↑ ");if(c->data.di==4)printf(" ← ");tag=1;break;}elsec=c->next;}if(tag==0)printf("%c ",m[i][j]);}printf("\n");}Statu MazePath(char map[SIZE][SIZE], PosType start, PosType end, LinkStack *path){ //这里编写代码，求解迷宫。
3.3_栈的应用--迷宫求解
程序流程图
开始
构建迷宫 迷宫求解
打印路径 结束
迷宫算法
通畅,则记录该点到栈中,并 判断是为终点,不为终点的 话,继续前行探索 判断当前结点是否通畅
设置访问东邻居开始,若其 不通,换方向探路
邻居访问遍,均不通,退出此 结点,取当前栈顶的未访问 邻居探路
不通畅,则后退,换方向访问, 到栈空结束
总结:对于一个入栈的节点要记录其位置(x,y),同时 记录其探索邻居的方向di(1,2,3,4)记录四个邻居 同时对于已经退出的节点标记无需标记其”不 通”,只要沿下一个方向转圈就可.
迷宫的分析
迷宫设置为一个2维数组，通路为1，不通为0，但是 四周为屏障 设置一个栈来存储迷宫的路径：记录每个位置的坐标 值（x,y),同时将纳入栈中的路径，记录它来自何方， 也就是记录它的探测方向编号（东，南，西，北类似 于地图的指示，1，2，3，4） 通的话就入栈操作：（x,y,di) 探测当前坐标位置的所有邻居均不通：出栈，打上脚 印，此路不通，不再加入 再对栈顶重新探测寻求新的邻居入栈 直到达到迷宫出口（有解）或退回到原路的入口（无 解）
注意问题
4．注意调试过程中的问题记录，以提高程 序调试的能力 5．调试过程中遇到死循环可用Ctrl+C或 Ctrl+Break退出。
实验结果
不同的算法会产生不同的结果。
若栈不空但栈顶位置的四周均不可通， 则｛删去栈顶位置；// 从路径中删去该通道块 若栈不空，则重新测试新的栈顶位置， 直至找到一个可通的相邻块或出栈至栈空； ｝ 若栈空，则表明迷宫没有通路。
实验内容
一个m×n的迷宫，0：畅通，1：障碍， 设计一个程序，对任意设定的迷宫，求出从入 口到出口的通路。入口：1 1；出口：6 8 0 1 0 1 1 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1 0 1 1 1 0 0 0 0
用栈求解迷宫问题所有路径及最短路径程序c语言
用栈求解迷宫问题所有路径及最短路径程序c语言
摘要：
1.迷宫问题的背景和意义
2.栈的基本概念和原理
3.用栈解决迷宫问题的方法
4.C 语言编程实现步骤
5.程序示例及运行结果
正文：
【1.迷宫问题的背景和意义】
迷宫问题是计算机科学中的一个经典问题，它涉及到图论、数据结构和算法等多个领域。
在迷宫问题中，给定一个有向图，目标是找到从起点到终点的所有路径以及最短路径。
这个问题在现实生活中也有很多应用，例如地图导航、物流路径规划等。
【2.栈的基本概念和原理】
栈是一种线性数据结构，它遵循后进先出（LIFO）的原则。
栈可以用来存储序列中的元素，也可以用来表示函数调用关系。
栈的操作通常包括入栈、出栈、获取栈顶元素等。
【3.用栈解决迷宫问题的方法】
为了解决迷宫问题，我们可以使用栈来记录遍历过程中的路径。
具体步骤如下：
1.创建一个栈，用于存储遍历过程中的路径；
2.从起点开始，将当前节点的编号入栈；
3.遍历当前节点的所有相邻节点，如果相邻节点未被访问过，则将其入栈；
4.当栈不为空时，继续执行步骤3；否则，说明已到达终点，开始回溯，找到最短路径；
5.从栈顶弹出节点，将其添加到结果路径列表中；
6.如果栈为空，说明没有找到从起点到终点的路径；否则，返回结果路径列表。
《数据结构》上机实验报告—利用栈实现迷宫求解
《数据结构》上机实验报告—利用栈实现迷宫求解实验目的：掌握栈的基本操作和迷宫求解的算法，并能够利用栈实现迷宫求解。
实验原理：迷宫求解是一个常见的路径问题，其中最常见的方法之一是采用栈来实现。
栈是一种先进后出的数据结构，适用于这种类型的问题。
实验步骤：1.创建一个迷宫对象，并初始化迷宫地图。
2.创建一个栈对象，用于存储待探索的路径。
3.将起点入栈。
4.循环执行以下步骤，直到找到一个通向终点的路径或栈为空：a)将栈顶元素出栈，并标记为已访问。
b)检查当前位置是否为终点，若是则路径已找到，结束。
c)检查当前位置的上、下、左、右四个方向的相邻位置，若未访问过且可以通行，则将其入栈。
5.若栈为空，则迷宫中不存在通向终点的路径。
实验结果：经过多次实验，发现利用栈实现迷宫求解的算法能够较快地找到一条通向终点的路径。
在实验中，迷宫的地图可通过一个二维数组表示，其中0表示可通行的路径，1表示墙壁。
实验结果显示，该算法能够正确地找出所有可行的路径，并找到最短路径。
实验结果还显示，该算法对于大型迷宫来说，解决速度相对较慢。
实验总结：通过本次实验，我掌握了利用栈实现迷宫求解的算法。
栈作为一种先进后出的数据结构，非常适合解决一些路径的问题。
通过实现迷宫求解算法，我深入了解了栈的基本操作，并学会运用栈来解决实际问题。
此外，我还了解到迷宫求解是一个复杂度较高的问题，对于大型迷宫来说，解决时间较长。
因此，在实际应用中需要权衡算法的速度和性能。
在今后的学习中，我将进一步加深对栈的理解，并掌握其他数据结构和算法。
我还将学习更多的路径算法，以便更好地解决迷宫类问题。
掌握这些知识将有助于我解决更加复杂的问题，并提升编程能力。
数据结构设计——用栈实现迷宫问题的求解
数据结构设计——⽤栈实现迷宫问题的求解求解迷宫问题1，问题描述以⼀个m*n的长⽅阵表⽰迷宫，0和1分别表⽰迷宫中的通路和障碍。
迷宫问题要求求出从⼊⼝（1，1）到出⼝（m,n）的⼀条通路，或得出没有通路的结论。
基本要求：⾸先实现⼀个以链表作存储结构的栈类型，然后编写⼀个求迷宫问题的⾮递归程序，求得的通路，其中：（i，j）指⽰迷宫中的⼀个坐标， d表⽰⾛到下⼀坐标的⽅向。
左上⾓（1，1）为⼊⼝，右下⾓（m,n）为出⼝。
2.设计思路： ⽤栈实现迷宫问题的求解；3．实验代码：栈实现迷宫求解问题：************************************************************************************************************1//maze_stack.cpp2 #include<stdio.h>3 #include<stdlib.h>4 #include<windows.h>5 #include"seqstack.h"67#define MAX_ROW 128#define MAX_COL 14910int maze[12][14] = {111, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,121, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,131, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,141, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,151, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,161, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,171, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,181, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,191, 0, 0, 0, 0, 1 ,0 ,0, 0 ,0 ,1 ,0 ,1 ,1,201, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,211, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,221, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 123 };2425void print_line()26 {27 system("cls");28 printf("迷宫如下‘■’代表墙,数字或者‘☆’表⽰路径\n");29int i, j;30for (i = 0; i < MAX_ROW; i++){31for (j = 0; j < MAX_COL; j++)32if (maze[i][j] == 1) printf("■");33else if (maze[i][j] >= 3){34 printf("%2d", maze[i][j] - 2);35/*if (i == MAX_ROW-2 && j == MAX_COL-2) printf("★");36 else printf("☆");*/37 }38else printf("");39 printf("\n");40 }41 printf("已到达出⼝...\n");42 printf("可见使⽤栈求出的路径并⾮最优路径，根据我依次探索的⽅向不同，结果也将不同\n");43 }4445void visit(mark p,int sign, PSeqStack S)46 {47 Push_SeqStack(S,p);48switch (sign)49 {50case1: p.col++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向右51case2: p.row++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向下52case3: p.col--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向左53case4: p.row--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向上54 }55 }5657int main()59struct point p = { 1, 1 };60 maze[p.row][p.col] = 2;//遍历过的点设置为261 PSeqStack S = Init_SeqStack();62 Push_SeqStack(S,p);63while (!Empty_SeqStack(S))64 {65 Pop_SeqStack(S, &p);66if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)67break;68if (p.col + 1 < MAX_COL - 1 && maze[p.row][p.col + 1] == 0)//向右69 {70 visit(p, 1, S);71continue;72 }73if (p.row + 1 < MAX_ROW - 1 && maze[p.row + 1][p.col] == 0)//向下74 {75 visit(p, 2, S);76continue;77 }78if (p.col - 1 >= 1 && maze[p.row][p.col - 1] == 0)//向左79 {80 visit(p, 3, S);81continue;82 }83if (p.row - 1 >= 1 && maze[p.row - 1][p.col] == 0)//向上84 {85 visit(p, 4, S);86continue;87 }//以上是对迷宫的四个⽅向进⾏操作88 }89if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)//是否为出⼝90 {91int count = GetLength_SeqStack(S)+3;//为了与迷宫0,1,2的区别所以基数要以3开始92 printf("成功找到出⼝，路径倒序输出：\n");93 printf("(%d,%d)\n", p.row, p.col);94 maze[p.row][p.col] = count;95while (!Empty_SeqStack(S))//按照前驱进⾏查找96 {97 count--;98 Pop_SeqStack(S, &p);99 maze[p.row][p.col] = count;100 printf("(%d,%d)\n", p.row, p.col);101 }102 printf("3秒后打印路径......");103 Sleep(3000);104 print_line();105 }106else {107 printf("没有出路\n");108 }109 system("pause");110return0;111 }112//end maze_stack.cpp************************************************************************************************************* 1//seqstack.h2 #include<stdio.h>3 #include<stdlib.h>4#define MAXSIZE 10056 typedef struct point{7int row, col;8 }mark;910 typedef mark DataType;1112 typedef struct {13 DataType data[MAXSIZE];14int top;15 }SeqStack, * PSeqStack;1617 PSeqStack Init_SeqStack (void)18 {19 PSeqStack S;20 S = (PSeqStack)malloc(sizeof(SeqStack));21if (S)22 S->top = -1;23else24 exit(-1);25return S;26 }28int Empty_SeqStack(PSeqStack S)29 {30//return (S->top==-1);31if (S->top == -1)32return1;33else34return0;35 }3637int Push_SeqStack(PSeqStack S,DataType x)38 {39if (S->top == MAXSIZE - 1)40 {41 printf("栈满不能⼊栈\n");42return0;43 }44else45 {46 S->top++;47 S->data[S->top] = x;48return1;49 }50 }5152int Pop_SeqStack(PSeqStack S,DataType *x)53 {54if(Empty_SeqStack(S))55return0;56else57 {58 *x = S->data[S->top];59 S->top--;60return1;61 }62 }6364int GetTop_SeqStack(PSeqStack S ,DataType *x) 65 {66if(Empty_SeqStack(S))67return0;68else69 {70 *x = S->data[S->top];71return1;72 }73 }74int GetLength_SeqStack(PSeqStack S)75 {76return S->top + 1;77 }7879void Distory_SeqStack(PSeqStack *S)80 {81if(*S)82free(*S);83 *S = NULL;84 }//end seqstack.h4.运⾏结果：栈求解迷宫：。
栈在迷宫求解问题中的应用
a=(SNode*)malloc(sizeof(SNode));
while(S->top!=NULL)
{
a=S->top;
S->top=S->top->next;
free(a);
}
return 0;
}
Statu readmaze(char map[SIZE][SIZE], int *row, int *col){
{
if(mark[path->top->next->data.seat.row-1][path->top->next->data.seat.col]==0||mark[path->top->next->data.seat.row][path->top->next->data.seat.col+1]==0||mark[path->top->next->data.seat.row+1][path->top->next->data.seat.col]==0||mark[path->top->next->data.seat.row][path->top->next->data.seat.col-1]==0)
a->data.seat.col=path->top->next->data.seat.col-1;
int stacksize ; /*当前栈容量，以元素为单位*/
}SqStack ;
（3）链栈的结构示意图
2、程序框架结构与流程图
（1）程序模块：
·迷宫生产模块：手动生成迷宫。
myscript calculator 实现原理
myscript calculator 实现原理
实现一个简单的计算器脚本（MyScript Calculator）的原理是
通过将用户输入的数学表达式作为字符串进行解析和计算。
具体实现原理如下：
1. 接收用户输入的数学表达式字符串。
2. 进行错误检查和修正，例如匹配括号、判断运算符位置等。
可以利用栈（Stack）数据结构来实现括号匹配，同时可以利
用逆波兰表达式等算法进行运算符位置判断和修正。
3. 将表达式字符串拆分成多个数字和运算符的组合，可以利用分词（Tokenization）的方法将字符串分解为多个操作数和运
算符。
4. 使用逆波兰表达式（Reverse Polish Notation）或其他类似算
法将中缀表达式转换为后缀表达式，即转换为适合计算的形式。
5. 利用栈（Stack）数据结构实现后缀表达式的计算。
依次读
取后缀表达式中的操作数和运算符，并进行相应的计算操作。
6. 返回计算结果，并输出给用户。
总结来说，MyScript Calculator的实现原理主要包括字符串解
析和修正、表达式转换和计算等步骤。
通过合理利用数据结构和算法，可实现一个简单而功能完善的计算器脚本。
用栈方法解决迷宫问题
pastack->t--;
}
/*当pastack所指的栈不为空栈时，求栈顶元素的值*/
DataType top_seq( PSeqStack pastack ) {
return (pastack->s[pastack->t]);
}
void pushtostack(PSeqStack st, int x, int y, int d) {
1,0,0,0,0,0,1,0,0,1,1,
1,0,1,1,1,0,0,0,1,1,1,
1,0,0,0,1,0,1,1,0,1,1,
1,1,0,0,1,0,1,1,0,0,1,
1,1,1,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1,1,1
};
mazePath(maze,direction,1,1,6,9);
getchar();
return 0;
}
while(!isEmptyStack_seq(st)) {
element = top_seq(Leabharlann t);pop_seq(st);
printf("the node is: %d %d \n", element.x, element.y);
}
}
/*迷宫maze[M][N]中求从入口maze[x1][y1]到出口maze[x2][y2]的一条路径*/
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int x;/*行下标*/
int y;/*列下标*/
int d;/*运动方向*/
利用栈实现迷宫求解
利用栈实现迷宫的求解
一、要解决的四个问题：
1、表示迷宫的数据结构：
设迷宫为 m 行 n 列，利用 maze[m][n]来表示一个迷宫，maze[i][j]=0 或 1; 其中：0 表示 通路，1 表示不通，当从某点向下试探时，中间点有 4 个方向可以试探，（见图）而四个角 点有 2 个方向，其它边缘点有 3 个方向，为使问题简单化我们用 maze[m+2][n+2]来表示迷 宫，而迷宫的四周的值全部为 1。这样做使问题简单了，每个点的试探方向全部为 4，不用 再判断当前点的试探方向有几个，同时与迷宫周围是墙壁这一实际问题相一致。
Push_SeqStack ( s, temp ) ; x=i ; y=j ; maze[x][y]= -1 ; if (x= =m&&y= =n) return 1 ; /*迷宫有路*/ else d=0 ; } else d++ ; } /*while (d<4)*/ } /*while (! Empty_SeqStack (s ) )*/ return 0 ;/*迷宫无路*/ } 栈中保存的就是一条迷宫的通路。
素有两个域组成，x：横坐标增量，y：纵坐标增量。Move 数组如图 3 所示。 move 数组定义如下： typedef struct { int x ; //行 int y ; //列 } item ; item move[4] ; 这样对 move 的设计会很方便地求出从某点 (x，y) 按某一方法思想如下：
(1) 栈初始化; (2) 将入口点坐标及到达该点的方向（设为-1）入栈 (3) while (栈不空)
C语言数据结构中求解迷宫问题实现方法
C语⾔数据结构中求解迷宫问题实现⽅法C语⾔数据结构中求解迷宫问题实现⽅法在学习数据结构栈的这⼀节遇到了求迷宫这个问题，拿来分享⼀下~⾸先求迷宫问题通常⽤的是“穷举求解” 即从⼊⼝出发，顺某⼀⽅向试探，若能⾛通，则继续往前⾛，否则原路返回，换另⼀个⽅向继续试探，直⾄⾛出去。
我们可以先建⽴⼀个8*8的迷宫其中最外侧为1的是墙int mg[M+2][N+2]={{1,1,1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1,0,1},{1,0,0,1,0,0,0,1,0,1},{1,0,0,0,0,1,1,0,0,1},{1,0,1,1,1,0,0,0,0,1},{1,0,0,0,1,0,0,0,0,1},{1,0,1,0,0,0,1,0,0,1},{1,0,1,1,1,0,1,1,0,1},{1,1,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1},}如上所⽰，0对应通道⽅块，1代表墙。
对于迷宫中的每个⽅块，有上下左右4个⽅块相邻，我们规定第i⾏第j列⽅块的位置为（i,j）规定上⽅⽅块⽅位为0，顺时针⽅向递增编号。
(i,j)上⽅的即为(i-1,j),下⽅(i+1,j)，左⽅(i,j-1)，右⽅(i,j+1). 为了⽅⾯回溯，我们需要有进栈出栈操作，所以我们来定义：struct {int i;//当前⽅位⾏int j;//当前⽅位列int di;//下⼀个可⾛⽅位号}St[MaxSize];//栈int top=-1;//初始化栈顶指针我们来看看⽂字过程~~⾸先将⼊⼝进栈（初始⽅位为-1），在栈不空的情况下循环：取栈顶⽅块（不退栈），若该⽅块是出⼝，则退栈。
若存在这样的⽅块，则将其⽅位保存到栈顶元素中，并将这个可⾛的相邻⽅块进栈。
对应的算法：void mgpath(int x1,int y1,int x2,int y2){int i.j,di,find,k;top++;St[top].i=x1; St[top].j=y1; St[top].di=-1; mg[x1][y1]=-1;while (top>-1){i=St[top].i; j=St[top].j; di=St[top].di;if (i==x2 && j==y2){printf("迷宫路径如下：\n");for (k=0;k<=top;k++){printf("\t(%d,%d)",St[k].i,S[k].j);if ((k+1)%5==0) printf("\n"); //输出5个换⼀⾏}printf("\n"); //找到⼀条路径后结束return ;}find=0;while (di<4 && find==0){di++;switch(di){case 0: i=St[top].i-1; j=S[top].j;break;case 1: i=St[top].i; j=St[top].j+1;break;case 2: i=St[top].i+1;j=St[top].j;break;case 3: i=St[top].i; j=St[top].j-1;break;}if(mg[i] [j]==0) find=1;}if (find==1){ //找到了下⼀个可⾛⽅块St[top].di=di;//修改原栈顶的值top++; //下⼀个可⾛⽅块进栈St [top].i=i; St[top].j=j;St[top].di=-1;mg[i] [j]=-1;//避免重复⾛到该⽅块}else{ //没有路径可⾛,进⾏退栈操作mg[St[top].i] [St[top].j]=0;//让该位置变为其他路径的可⾛⽅块top--;}}printf("没有路径可⾛!\n");}当然我们也可以⽤队列去求该迷宫的最优算法，这只是⼀个⽤来理解栈的例⼦~~~感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。
迷宫问题栈算法c++代码
迷宫问题栈算法c++代码迷宫问题是一个经典的寻路问题，目标是从迷宫的入口找到出口的路径。
栈是一个常用的数据结构，可以用来实现迷宫问题的解决方法。
下面是使用栈算法解决迷宫问题的C++代码。
```cpp#include <iostream>#include <stack>#include <vector>using namespace std;// 定义迷宫的大小const int N = 5;const int M = 5;// 定义迷宫的地图，0 表示可通行的路径，1 表示墙壁int maze[N][M] = {{0, 1, 0, 0, 0},{0, 1, 0, 1, 0},{0, 0, 0, 0, 0},{0, 1, 1, 1, 0},{0, 0, 0, 1, 0}};// 定义方向数组，分别表示右、下、左、上四个方向移动int dx[] = {1, 0, -1, 0};int dy[] = {0, 1, 0, -1};// 定义迷宫中的点struct Point {int x, y;};// 判断某个点是否在迷宫内且可通行bool isValid(int x, int y) {return x >= 0 && x < N && y >= 0 && y < M && maze[x][y] == 0;}// 使用栈算法寻找迷宫路径vector<Point> findPath(int startX, int startY, int endX, int endY) {stack<Point> s;vector<Point> path;bool visited[N][M] = {false};// 将起点加入栈中s.push({startX, startY});visited[startX][startY] = true;while (!s.empty()) {// 获取栈顶点Point current = s.top();s.pop();// 判断是否到达终点if (current.x == endX && current.y == endY) { path.push_back(current);break;}// 遍历四个方向for (int i = 0; i < 4; i++) {int nextX = current.x + dx[i];int nextY = current.y + dy[i];// 判断下一个点是否合法且未访问过 if (isValid(nextX, nextY)&& !visited[nextX][nextY]) {s.push({nextX, nextY});visited[nextX][nextY] = true; }}// 如果栈为空，说明无法到达终点if (s.empty()) {cout << '无法找到路径！' << endl; return path;}}// 反向输出路径while (!s.empty()) {path.push_back(s.top());s.pop();}return path;}int main() {int startX, startY, endX, endY;cout << '请输入起点坐标（以空格分隔）：';cin >> startX >> startY;cout << '请输入终点坐标（以空格分隔）：';cin >> endX >> endY;vector<Point> path = findPath(startX, startY, endX, endY);if (!path.empty()) {cout << '找到路径！路径长度为：' << path.size() << endl; cout << '路径为：';for (int i = path.size() - 1; i >= 0; i--) {cout << '(' << path[i].x << ', ' << path[i].y << ')';if (i != 0) {cout << ' -> ';}}}return 0;}```以上代码通过栈算法实现了迷宫问题的解决方法。
应用栈解决迷宫问题的C语言实现
应⽤栈解决迷宫问题的C语⾔实现题⽬来⾃于严蔚敏《数据结构》，参考伪代码实现的程序：1 #include <stdio.h>2 #include <malloc.h>3//记录通道块在迷宫矩阵当中的横、纵坐标4struct Position{5int x;6int y;7 };8//放⼊栈当中的通道块元素9struct SElement {10int ord;//记录此通道块在整个通道当中的次序11 Position p;//记录此通道块在矩阵当中的位置12int di;//记录下⼀次测试这⼀路径的临近路径的位置13 };14//创建栈数据结构15#define STACK_INIT_SIZE 10016#define STACKINCREMENT 1017struct MyStack{18 SElement* base;19 SElement* top;20int stacksize;21 };22//创建⼀个栈如果创建成功则返回1，否则就返回023int InitStack(MyStack* s)24 {25 s->base=(SElement*)malloc(STACK_INIT_SIZE*sizeof(SElement));//为栈分配初始空间26if(!s->base) return0;27 s->top=s->base;//设定为空栈28 s->stacksize=STACK_INIT_SIZE;29return1;30 }31//判断栈是否为空，如果是空的就返回0，否则就返回132int IsStackEmpty(MyStack* s)33 {34if(s->top==s->base) return true;35return false;36 }37//获取栈顶元素,如果栈为空就返回0 否则就返回138int GetTop(MyStack* s,SElement* e)39 {40if(IsStackEmpty(s)) return0;41 e=s->top-1;42return1;43 }44//获取栈的长度，并且通过程序返回45int StackLength(MyStack* s)46 {47return s->top-s->base;48 }49//插⼊元素e为新的栈顶元素，插⼊成功则返回1，否则返回050int Push(MyStack* s,SElement e)51 {52if(s->top-s->base>=STACK_INIT_SIZE)53 {54 s->base=(SElement*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(SElement));55if(!s->base) return0;56 s->top=s->base+s->stacksize;57 s->stacksize+=STACKINCREMENT;58 }59 *(s->top)=e;60 s->top++;61return1;62 }63//弹出栈顶元素赋值给e弹出成功返回1，弹出失败返回064int Pop(MyStack* s,SElement* e)65 {66if(IsStackEmpty(s)) return0;67 *e=*(s->top-1);68 s->top--;69return1;70 }71//定义墙元素为2 可⾛路径为0 已知路径为curStep 不能够通过的路径为-172#define MazeScale 1073int Maze[MazeScale][MazeScale]={{2,2,2,2,2,2,2,2,2,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,0,0,2,2,0,0,2},74 {2,0,2,2,2,0,0,0,0,2},{2,0,0,0,2,0,0,0,0,2},{2,0,2,0,0,0,2,0,0,2},{2,0,2,2,2,0,2,2,0,2},{2,2,0,0,0,0,0,0,0,2},{2,2,2,2,2,2,2,2,2,2}}; 75//辅助函数考察当前路径能否通过76bool Pass(Position posi)77 {78//只有路径所在位置的数字为0的是可以⾛的79if(Maze[posi.x][posi.y]==0)80 {81return true;82 }83return false;84 }85//按顺时针⽅向从东开始寻找矩阵当中某⼀个位置的临近位置86 Position NextPosition(Position now,int direction)87 {88 Position next;89int x=now.x;90int y=now.y;91switch(direction)92 {93//东94case1:{95 next.x=x;96 next.y=y+1;97break;98 }99//南100case2:{101 next.x=x+1;102 next.y=y;103break;104 }105//西106case3:{107 next.x=x;108 next.y=y-1;109break;110 }111//北112case4:113 {114 next.x=x-1;115 next.y=y;116break;117 }118default:break;119 }120return next;121 }122//留下⾜迹123void FootPrint(Position p,int step)124 {125 Maze[p.x][p.y]=step;126 }127//路径不可⾛的话就留下-1的标记128void MarkPrint(Position p)129 {130 Maze[p.x][p.y]=-1;131 }132int main()133 {134//打印出迷宫矩阵135for(int i=0;i<MazeScale;i++)136 {137for(int j=0;j<MazeScale;j++)138 {139 printf("%d ",Maze[i][j]);140 }141 printf("\n");142 }143//迷宫程序主体144 MyStack path;//记录路径的栈145 InitStack(&path);//初始化路径数组146 Position curp;//当前被试位置147//初始化当前位置为矩阵⼊⼝148 curp.x=1;149 curp.y=1;150int curStep=1;//被探索的步数151do152 {153if(Pass(curp))154 {155 FootPrint(curp,curStep);//可⾛就在迷宫⾥⾯留下⾜迹156//创建⼀个栈元素，存储可⾏路径的相关值，将这个元素存储到栈当中157 SElement e;158 e.di=1;//意味着下⼀个被试路块为这⼀个路块的正上⽅的路块159 e.ord=curStep;160 e.p.x=curp.x;161 e.p.y=curp.y;162 Push(&path,e);//将路径块⼊栈163if(curp.x==MazeScale-2 && curp.y==MazeScale-2) break; //如果被压⼊的路径块到了迷宫的终点就退出循环164//找到下⼀个被试块165 curp=NextPosition(curp,1);//找到前⼀个被试块东⾯的路径块作为被试块166 curStep++;//被探索的步数加⼀167 }else//如果当前被试路径不能够通过的话168 {169if(!IsStackEmpty(&path))170 {171 SElement e;172 Pop(&path,&e);173 curStep--;174//将这⼀段所有的周围路径都已经被测试过的路径从栈中清除175while(e.di==4 && !IsStackEmpty(&path)){176 MarkPrint(e.p);177 Pop(&path,&e);178 curStep--;179 }180//如果当前栈顶还有未被测试的路径就测试剩余的周围路径181if(e.di<4)182 {183 curp=NextPosition(e.p,e.di+1);184 e.di++;185 curStep++;186 Push(&path,e);187 }188 }189 }190 }while(!IsStackEmpty(&path));191 printf("\n");192//打印出结果迷宫矩阵193for(int i=0;i<MazeScale;i++)194 {195for(int j=0;j<MazeScale;j++)196 {197 printf("%d ",Maze[i][j]);198 }199 printf("\n");200 }201return0;202 }。
用栈解决迷宫问题
⽤栈解决迷宫问题⼀、因为栈是后进先出的特性，所以说⼀般⽤栈都是通过dfs来解决迷宫问题。
如果⽤队列的话就是通过bfs来解决。
⼆、c++代码：1 #include<iostream>2 #include<cstdio>3 #include<stdio.h>4 #include<string.h>5 #include<windows.h>6using namespace std;7const int maxn=1005;8#define MaxSize 100005 //栈最多元素个数9int M=4,N=4;10int w[6][6]=11 {12 {1,1,1,1,1,1}13 ,{1,0,0,0,1,1}14 ,{1,0,1,0,0,1}15 ,{1,0,0,0,1,1}16 ,{1,1,0,0,0,1}17 ,{1,1,1,1,1,1}18 };19int mg[maxn][maxn];20char s[maxn][maxn];21struct migong22 {23int i; //路径横坐标24int j; //路径纵坐标25int di; //⽅向26 } Stack[MaxSize],Path[MaxSize]; //定义栈和存放最短路径的数组27int top=-1; //栈顶指针28int counts=1; //路径数计数29int minlen=MaxSize; //最短路径长度30void mgpath() //路径为:(1,1)->(M,N)31 {32int i,j,di,finds,k;33 top++;34 Stack[top].i=1;35 Stack[top].j=1;36 Stack[top].di=-1;37 mg[1][1]=-1; //初始结点进栈38while(top>-1) //栈不空时循环39 {40 i=Stack[top].i;41 j=Stack[top].j;42 di=Stack[top].di;43if(i==M && j==N) //找到了出⼝，输出路径44 {45// cout<<counts<<": ";46// counts++;47// for(k=0; k<=top; k++)48// {49// cout<<"("<<Stack[k].i<<","<<Stack[k].j<<")"<<" ";50//51// }52// cout<<endl;53if(top+1<minlen) //⽐较输出最短路径54 {55for(k=0; k<=top; k++)56 Path[k]=Stack[k];57 minlen=top+1;58 }59 mg[Stack[top].i][Stack[top].j]=0; //让该位置变为其他路径的可⾛结点60 top--;61 i=Stack[top].i;62 j=Stack[top].j;63 di=Stack[top].di;64 }65 finds=0;66while(di<4 && finds==0) //找下⼀个可⾛结点67 {68 di++;69switch(di)70 {71case0:72 i=Stack[top].i-1;73 j=Stack[top].j;74break; //上⾯75case1:76 i=Stack[top].i;77 j=Stack[top].j+1;78break; //右边79case2:80 i=Stack[top].i+1;82break; //下⾯83case3:84 i=Stack[top].i;85 j=Stack[top].j-1;86break; //左边87 }88if(mg[i][j]==0) //因为地图外边围了⼀层墙，所以不需要判断边界89 finds=1;90 }91if(finds == 1) //找到了下⼀个可⾛结点92 {93 Stack[top].di=di; //修改原栈顶元素的di值94 top++; //下⼀个可⾛结点进栈95 Stack[top].i=i;96 Stack[top].j=j;97 Stack[top].di=-1;98 mg[i][j]=-1; //避免重复⾛到该结点99 }100else101 {102 mg[Stack[top].i][Stack[top].j]=0; //让该位置变为其他路径的可⾛结点103 top--;104 }105 }106 cout<<"最短路径如下(输出结果以坐标显⽰)"<<endl;107 cout<<"长度: "<<minlen<<endl;108 cout<<"路径: "<<endl;109for(k=0; k<minlen; k++)110 {111 cout<<"("<<Path[k].i<<","<<Path[k].j<<")"<<"";112 }113 }114int main()115 {116int x;117while(1)118 {119 system("cls");120 printf ( " 迷宫系统 \n");121 printf ( " \n");122 printf ( " \n");123 printf ("-------------------------------------- \n");124 printf ("--------------------------------------\n");125 printf ("--------⼁[0]重构地图⼁---\n");126 printf ("--------⼁[1]使⽤默认地图⼁---\n");127 printf ("--------⼁[2]结束⼁---\n");128 printf ("----------输⼊相应数字----------------\n");129 printf ("--------------------------------------- \n");130 printf ( " \n");131 printf ( " \n");132 scanf("%d",&x);133if(x==0)134 {135 system("cls");136 printf(" 重构地图\n");137 printf("输⼊内容请以空格或者换⾏分隔开，且0代表此处可⾛，1代表此处不可⾏\n"); 138 printf("\n现在请输⼊地图是⼏⾏⼏列\n");139int n,m;140 memset(mg,0,sizeof(mg));141 scanf("%d%d",&n,&m);142int flag=0;143 printf("\n请输⼊地图,请保证左上⾓和右下⾓都为0\n");144for(int i=1; i<=n; ++i)145 {146147 scanf("%s",s[i]+1);148 mg[i][0]=mg[i][m+1]=1;149 }150for(int j=1; j<=m; ++j)151 {152 mg[0][j]=mg[n+1][j]=1;153 }154for(int i=1;i<=n;++i)155 {156for(int j=1;j<=m;++j)157 {158 mg[i][j]=s[i][j]-'0';159 }160 }161 M=n;162 N=m;163164//cout<<"迷宫所有路径如下:"<<endl;165 mgpath();166 system("pause");167 }168else if(x==1)169 {171 M=N=4;172for(int i=0; i<6; ++i) 173 {174for(int j=0; j<6; ++j) 175 {176 mg[i][j]=w[i][j]; 177 }178 }179 mgpath();180 system("pause"); 181 }182else break;183 }184return0;185 }View Code。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验内容：
采用C++语言基于栈的各种操作，将进制数N转换为d 进制的数，其转换方法利用辗转相除法：N=(N div d) *d + N mod d来转化，要求能实现十进制数转化为任意进制的 数，并能成功的将其输出。 采用安卓程序编写一个迷宫小游戏程序，熟悉栈的相 关知识。迷宫用到Java语言谢谢
2014-12-2
用栈实现迷宫求解和数制转化软件
信息与计算科学121
实验目的：
1.熟悉栈的表示和实现方法，基于相应的表示实现； 2.掌握栈各种操作，并能进行迷宫求解； 3.基于栈的各种操作，做一个简单数制转化软件。
实验要求：
1）通过实验，要求学生掌握栈的存储方法； 2）基于相应的存储表示，熟悉实现栈的初始化、入栈和 出栈点等算法； 3）基于栈的基础理论实现迷宫求解和数制化转化软件， 并认真完成实验报告。
实验原理：
基于栈的操作，十进制转化为任意进制数的算法思想是 先判断十进制数N>0是否成立，如果成立，就执行以下两个 步骤：（1）若 N≠0,则将N % d 压入栈s中 ，执行2; 若N=0， 将栈s的内容依次出栈，算法结束。（2）用N / d 代替 N。 基于栈的基本操作，运用eclipse平台实现迷宫求解。迷 宫是一个方阵区域，可以使用二维数组表示迷宫的每一个位 置。迷宫中存在通路和障碍，为了方便迷宫的创建，可用0 表示通路，用1表示障碍，也可以用别的符号表示通路和障 碍。 为了迷宫求解算法的通用性，自行设定走迷宫的规则， 定义一个较大的二维数组 ,然后用它的前 ( )行 列来存放走过 的位置，即可得到一个 的二维数组，这样(1,1)表示迷宫入口 位置， 表示迷宫出口位置。然后，基于迷宫求解算法输出通 路路径的长度，以及用二维数组输出通路路径。