C语言数据结构迷宫问题

合集下载

c语言迷宫问题课程设计

c语言迷宫问题课程设计

c语言迷宫问题课程设计一、课程目标知识目标:1. 学生能理解并掌握C语言中的基本控制结构,包括顺序结构、选择结构和循环结构。

2. 学生能运用数组的概念,实现迷宫的二维表示。

3. 学生能理解并实现递归算法,解决迷宫路径搜索问题。

技能目标:1. 学生能够设计并编写C语言程序,实现迷宫的创建和路径的寻找。

2. 学生通过迷宫问题,培养逻辑思维和问题解决能力,能够将复杂问题分解为小问题逐一解决。

3. 学生能够运用调试工具,对程序进行调试和优化,提高代码的执行效率。

情感态度价值观目标:1. 学生在探索迷宫问题的过程中,培养对编程的兴趣,增强学习信息技术的信心和热情。

2. 学生通过团队协作解决问题,培养沟通协作能力和集体荣誉感。

3. 学生能够体会到编程解决问题的成就感,激发继续深入学习计算机科学的兴趣。

课程性质:本课程为高年级信息技术课程,以项目式学习方式展开,强调理论与实践相结合。

学生特点:学生具备基本的C语言知识,具有一定的逻辑思维和问题解决能力。

教学要求:教师需引导学生主动探索,鼓励学生提出问题、分析问题并解决问题,注重培养学生的实际操作能力和团队协作能力。

通过本课程的学习,使学生将所学知识应用于实际问题的解决中,提高综合运用能力。

二、教学内容本课程以C语言迷宫问题为载体,结合以下教学内容,确保学生能够达成课程目标:1. C语言基础知识回顾:包括变量、数据类型、运算符、控制结构(顺序、选择、循环)。

2. 二维数组:数组的概念、二维数组的定义和使用,以及如何用二维数组表示迷宫。

3. 递归算法:递归的定义、递归调用的执行过程,以及如何利用递归求解迷宫路径。

4. 程序调试与优化:介绍调试工具的使用,指导学生如何查找并修正程序中的错误,提高代码执行效率。

教学内容安排:第一课时:C语言基础知识回顾,导入迷宫问题,讨论迷宫问题的解决思路。

第二课时:学习二维数组,学生尝试使用二维数组创建迷宫。

第三课时:介绍递归算法,分析迷宫问题中递归的应用。

c语言实现 迷宫问题

c语言实现  迷宫问题

数据结构试验——迷宫问题(一)基本问题1.问题描述这是心理学中的一个经典问题。

心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入,让老鼠自行找到出口出来。

迷宫中设置很多障碍阻止老鼠前行,迷宫唯一的出口处放有一块奶酪,吸引老鼠找到出口。

简而言之,迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。

本题设置的迷宫如图1所示。

图1 迷宫示意图迷宫四周设为墙;无填充处,为可通处。

设每个点有四个可通方向,分别为东、南、西、北(为了清晰,以下称“上下左右”)。

左上角为入口。

右下角为出口。

迷宫有一个入口,一个出口。

设计程序求解迷宫的一条通路。

2.数据结构设计以一个m×n的数组mg表示迷宫,每个元素表示一个方块状态,数组元素0和1分别表示迷宫中的通路和障碍。

迷宫四周为墙,对应的迷宫数组的边界元素均为1。

根据题目中的数据,设置一个数组mg如下int mg[M+2][N+2]={{1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1},{1,1,0,0,0,1,1,1},{1,0,0,1,0,0,0,1},{1,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1}};在算法中用到的栈采用顺序存储结构,将栈定义为Struct{ int i; 增量数组move[4]如图3所示。

图2数组move[4]方位示意图如下:通路:通路上的每一个点有3个属性:一个横坐标属性i、一个列坐标属性j和一个方向属性di,表示其下一点的位置。

如果约定尝试的顺序为上、右、下、左(即顺时针方向),则每尝试一个方向不通时,di值增1,当d增至4时,表示此位置一定不是通路上的点,从栈中去除。

在找到出口时,栈中保存的就是一条迷宫通路。

(1)下面介绍求解迷宫(xi,yj)到终点(xe,ye)的路径的函数:先将入口进栈(其初始位置设置为—1),在栈不空时循环——取栈顶方块(不退栈)①若该方块为出口,输出所有的方块即为路径,其代码和相应解释如下:int mgpath(int xi,int yi,int xe,int ye) =xi;st[top].j=yi;st[top].di=-1;mg[1][1]=-1;while (top>-1);j=st[top].j;di=st[top].di; ,st[k].j);if ((k+1)%5==0) -1;j=st[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;i=di; =i;st[top].j=j;st[top].di=-1;mg[i][j]=-1; ][st[top].j]=0;计思想(1)设置一个迷宫节点的数据结构。

数据结构(C语言版)实验报告(迷宫)

数据结构(C语言版)实验报告(迷宫)

《数据结构与算法》实验报告评分依据及结果一、需求分析1.问题描述:以一个m*n的长方阵表示迷宫,空格和感叹号分别表示迷宫中的通路和障碍。

设计一个程序,对随机产生的迷宫,求一条从入口到出口的通路,或得出没有通路的结论。

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

求得的通路以三元组(i,j,d)的形式输出。

其中(i,j)表示迷宫的一个坐标,d表示走到下一座标的方向。

3.程序的执行命令有:1)输入迷宫的列数2)输入迷宫的行数二、概要设计为实现上述功能,需要以一个链表为存储结构的栈类型1.栈的顺序存储表示typedef struct{int x; /*列*/int y; /*行*/}PosType; //坐标位置类型typedef struct{int ord; //通道块在路径上的"序号"PosType seat; //通道块在迷宫中的"坐标位置"int di; //从此通道块走向下一通道块的"方向"}SElemType; //栈的元素类型typedef struct{SElemType *base;SElemType *top;int stacksize; //当前已分配的存储空间,以元素为单位}SqStack;//迷宫程序typedef struct{int lie; /*列数*/int hang; /*行数*/char a[999][999];}MazeType; /*迷宫类型*/2.基本操作int InitStack(SqStack *S)//分配空间int GetTop(SqStack *S,SElemType *e) //若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERRORint Push(SqStack *S,SElemType *e)//插入元素e作为新的栈顶元素int Pop(SqStack *S,SElemType *e) //若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORint generatemaze( MazeType *maze)// 随机生成迷宫int Pass(MazeType *maze, PosType curpos ) //判断当前位置可否通过int FootPrint(MazeType *maze,PosType curpos) //留下足迹int MarkPrint(MazeType *maze,PosType curpos) //留下不能通过的标记PosType NextPos(PosType curpos,int di) //返回当前位置的下一位置int MazePath(MazeType *maze,PosType start,PosType end) //若迷宫有解,则求得一条存放在栈中(从栈底到栈顶),并返回OK,否则返回ERROR void PrintMaze(MazeType *maze) //打印迷宫三、详细设计//程序的头文件#include <stdio.h>#include <malloc.h>#include <stdlib.h>#include <string.h>#include <time.h>//函数的返回值#define OK 1#define ERROR 0#define NULL 0#define OVERFLOW -2#define STACK_INIT_SIZE 100#define STACKINCREMENT 10//栈的顺序存储表示typedef struct{int x; /*列*/int y; /*行*/}PosType; //坐标位置类型typedef struct{int ord; //通道块在路径上的"序号"PosType seat; //通道块在迷宫中的"坐标位置"int di; //从此通道块走向下一通道块的"方向"}SElemType; //栈的元素类型typedef struct{SElemType *base;SElemType *top;int stacksize; //当前已分配的存储空间,以元素为单位}SqStack;//基本操作int InitStack(SqStack *S){S->base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S->base)exit(OVERFLOW);S->top=S->base;S->stacksize=STACK_INIT_SIZE;return OK;}//若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERRORint GetTop(SqStack *S,SElemType *e){if(S->top==S->base)return ERROR;*e=*(S->top-1);return OK;}int Push(SqStack *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+=STACKINCREMENT;}*S->top++=*e;return OK;}//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORint Pop(SqStack *S,SElemType *e){if(S->top==S->base)return ERROR;*e=*--S->top;return OK;}int StackEmpty(SqStack *S){return(S->top==S->base);}//迷宫程序typedef struct{int lie; /*列数*/int hang; /*行数*/char a[999][999];}MazeType; /*迷宫类型*//*随机生成迷宫*/int generatemaze( MazeType *maze){int i,j;maze->a[0][0]=2;maze->a[++maze->hang][++maze->lie]=3; /*设置外墙*/maze->a[0][maze->lie]='!';maze->a[maze->hang][0]='!';for(j=1;j<maze->lie;j++){maze->a[0][j]='!';maze->a[maze->hang][j]='!';}for(i=1;i<maze->hang;i++){maze->a[i][0]='!';maze->a[i][maze->lie]='!';}srand((unsigned)time( NULL ));rand();for(i=1; i <maze->hang; i++)for(j=1;j<maze->lie;j++){if (rand()>=RAND_MAX/4) maze->a[i][j] =' '; //' ' 暗示出路else maze->a[i][j] ='!'; //'!'暗示无出路}return OK;}int Pass(MazeType *maze, PosType curpos ) //判断当前位置可否通过{if ((curpos.x < 1) || (curpos.x >= maze->lie))return ERROR;if ((curpos.y < 1) || (curpos.y >= maze->hang))return ERROR;if (maze->a[curpos.y][curpos.x]==' ')return OK;else return ERROR;}int FootPrint(MazeType *maze,PosType curpos) //留下足迹{maze->a[curpos.y][curpos.x]='*';return OK;}int MarkPrint(MazeType *maze,PosType curpos) //留下不能通过的标记{maze->a[curpos.y][curpos.x]='@';return OK;}PosType NextPos(PosType curpos,int di)//返回当前位置的下一位置{PosType pos=curpos;switch(di){case 1: //右东pos.x++;break;case 2: //下南pos.y++;break;case 3: //左西pos.x--;break;case 4: //上北pos.y--;break;}return pos;}//若迷宫有解,则求得一条存放在栈中(从栈底到栈顶),并返回OK,否则返回ERROR int MazePath(MazeType *maze,PosType start,PosType end){PosType curpos;SqStack *S=(SqStack *)malloc(sizeof(SqStack));InitStack(S);SElemType *e;e=(SElemType *)malloc(sizeof(SElemType));curpos=start; //设定当前位置为入口位置int curstep = 1; //探索第一步do {if(Pass(maze,curpos)) //当前位置可通过{FootPrint(maze,curpos);e->ord=curstep;e->seat=curpos;e->di=1;Push(S,e);if(curpos.x==end.x&&curpos.y==end.y)return (OK);curpos=NextPos(curpos,1);curstep++;}else{if(!StackEmpty(S)){Pop(S,e);while(e->di==4&&!StackEmpty(S)) //栈不空但栈顶位置四周均不通{MarkPrint(maze,e->seat);Pop(S,e);}if(e->di<4) //栈不空且栈顶位置四周有其他位置未探索{e->di++;Push(S,e);curpos=e->seat;curpos=NextPos(curpos,e->di);}}}}while(!StackEmpty(S));return ERROR;}void PrintMaze(MazeType *maze) //打印迷宫{int i,j,k,n;int c[999],d[999];for(i=0,k=0;i<=maze->hang;i++){for(j=0;j<=maze->lie;j++){printf("%c ",maze->a[i][j]);if(maze->a[i][j]=='*'){c[k]=i;d[k]=j;k++;}}printf("\n");}n=k;for(k=0;k<n;k++)printf("<%d,%d>",c[k],d[k]);printf("\n");printf("\n");}int main(){int zmg;char ch;printf(" 数据结构课程设计--迷宫问题求解\n\n");printf(" |----------------------------------------|\n");printf(" | |\n");printf(" | |\n");printf(" | |\n");printf(" | |\n");printf(" | XXXX XXXXXXXXXXXXXX |\n");printf(" | XXXXXXX |\n");printf(" |----------------------------------------|\n");getchar();do{system("cls");fflush(stdin);MazeType *maze=(MazeType *)malloc(sizeof(MazeType)); //设置迷宫的长宽不含外墙printf("请输入迷宫的列数(不含外墙时):");scanf("%d",&maze->lie);printf("请输入迷宫的行数(不含外墙时):");scanf("%d",&maze->hang);generatemaze(maze);printf("随机创建迷宫\n");PrintMaze(maze);getchar();getchar();PosType start,end;start.x=1;start.y=1;end.x=maze->lie-1;end.y=maze->hang-1;zmg=MazePath(maze,start,end);if(zmg){printf("此迷宫通路为\n");PrintMaze(maze);}elseprintf("此迷宫无通路\n"); //getchar();printf("再次尝试?(Y/N)?");scanf("%c",&ch);}while(ch=='Y'||ch=='y');return 0;}四、调试分析1.本程序界面设计合理,以空格为通路,感叹号!为障碍,笑脸为起始点,*为行走路线,心形为出口设计精巧,便于用户使用。

用C语言解决迷宫问题

用C语言解决迷宫问题

⽤C语⾔解决迷宫问题#include <stdio.h>#include <stdlib.h>#define ROW 10#define COL 10/*迷宫中位置信息*/typedef struct position{int x;int y;}position;/*在迷宫中的当前位置的信息,也是⼊栈的基本元素*/typedef struct SElem{int di;position seat;}SElem;/*链式栈中节点的定义*/typedef struct position_stack{SElem p;struct position_stack *next;}*Stack_pNode,Stack_Node;void InitStack(Stack_pNode *Link){*Link = NULL;}void push(Stack_pNode *Link,SElem e){Stack_pNode new_SElem = (Stack_pNode)calloc(1,sizeof(Stack_Node));new_SElem->p = e;new_SElem->next = NULL;if (*Link == NULL)*Link = new_SElem;else{new_SElem->next = *Link;*Link = new_SElem;}}int pop(Stack_pNode *Link,SElem *e){if (*Link == NULL)return 0;*e = (*Link)->p;Stack_pNode q = *Link;*Link = (*Link)->next;free(q);return 1;}int top(Stack_pNode Link, SElem *e){if (Link == NULL)return 0;*e = Link->p;return 1;}int empty(Stack_pNode Link){if (Link == NULL)return 1;elsereturn 0;}int reverse(Stack_pNode *Link){Stack_pNode p, q, r;if (*Link == NULL || (*Link)->next == NULL)return 0;r = *Link;p = (*Link)->next;q = NULL;while (p){r->next = q;q = r;r = p;p = p->next;}r->next = q;*Link = r;}void print(Stack_pNode Link){Stack_pNode r = Link;while (r){printf("(%d,%d) -> ",r->p.seat.x,r->p.seat.y);r = r->next;}printf("exit\n");}int curstep = 1;/*纪录当前的⾜迹,填写在探索前进的每⼀步正确的路上*//*迷宫地图。

C语言实现数据结构迷宫实验

C语言实现数据结构迷宫实验

C语⾔实现数据结构迷宫实验本⽂实例为⼤家分享了C语⾔实现简单的数据结构迷宫实验,供⼤家参考,具体内容如下分析:迷宫实验主要有两部分操作,其⼀是对迷宫的⽣成,其⼆是寻路使⽤栈的操作。

步骤:⼀、.h⽂件1、⾸先是迷宫的⽣成,可以使⽤随机数种⼦⽣成,但主要逻辑部分并不在此,所以在这⾥直接写死,固定下来。

定义⼀个坐标类型的结构体,和⼆维数组迷宫:typedef struct {int x;int y;}Pos;//迷宫类型typedef struct {int square[10][10] ={{1,1,1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0,0,1},{1,1,1,1,0,1,1,1,0,1},{1,0,0,0,0,1,0,1,0,1},{1,0,1,1,1,1,0,1,1,1},{1,0,0,0,0,1,0,0,0,1},{1,0,1,1,0,0,0,1,0,1},{1,0,1,1,1,0,1,1,1,1},{1,0,0,0,1,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1},};}Maze;typedef Pos SElemType;2、然后是对栈的声明,栈⾥储存的元素为坐标类型//顺序栈#define MAXSIZE 50typedef struct {SElemType *base;SElemType *top; //栈顶指针int stacksize;}SqStack;3、栈操作函数声明typedef int Status;#define OK 1;#define ERROR 0;//栈的相关操作//初始化栈Status initStack(SqStack &s);//压栈Status push(SqStack &s, SElemType e);//出栈SElemType pop(SqStack &s);//清空栈Status clearStack(SqStack &s);//摧毁栈void destroyStack(SqStack &s);//遍历栈Status stackTravel(SqStack s);4、迷宫操作函数声明//初始化迷宫(同时⽣成起始点和终点)void initMaze(Maze &maze);//寻找出路;传⼊⼀个迷宫和栈找出出路void findWay(Maze &maze,SqStack &s);//判断该点的四个⽅向是否有通路,有就前进Pos isExit(Pos p, Maze maze);⼆、.cpp⽂件1、导⼊所需头⽂件#include "pch.h"#include <iostream>#include<time.h>#include<stdlib.h>using namespace std;2、栈操作实现//构造空栈Status initStack(SqStack &s) {s.base = new SElemType[MAXSIZE];if (!s.base){exit(OVERFLOW);//分配失败}s.top = s.base;s.stacksize = MAXSIZE;return OK;}//⼊栈Status push(SqStack &s, SElemType e) {//判断栈满if (s.top-s.base == s.stacksize){return ERROR;}//存⼊元素,*为取指针的值s.top++;*s.top = e;return OK;}//出栈,⽤e返回栈顶值SElemType pop(SqStack &s) {SElemType e;//判断栈为空if (s.top == s.base){//若为空则返回⼀个(-1,-1)的点,判断由外部调⽤时进⾏ e.x = -1;e.y = -1;return e;}e = *s.top;s.top--;return e;}Status clearStack(SqStack &s) {s.top = s.base;return OK;}void destroyStack(SqStack &s) {s.top = NULL;s.stacksize = 0;free(s.base);}Status stackTravel(SqStack s) {while (s.top != s.base){s.base++;Pos p = *s.base;if ( p.x == 0 || p.y == 0|| p.x == 9 ||p.y == 9){//终点输出为“End”cout << "End";}}cout << endl;return 0;}3、迷宫操作实现///////////////////////////////////////迷宫操作//////////////////////////////////初始化函数,传⼊⼀个迷宫,随机⽣成起点和终点,由于起点有⼀定限制,所以这⾥起点也固定为⼏个最合适的点void initMaze(Maze &maze) {//⽣成随机数srand((unsigned)time(NULL));int index = rand() % 36 + 1;int start = index % 6 + 1;//⽣成起始点数值为‘s'switch (start){case 1:maze.square[1][1] = 's';break;case 2:maze.square[3][8] = 's';break;case 3:maze.square[3][6] = 's';break;case 4:maze.square[6][8] = 's';break;case 5:maze.square[8][3] = 's';break;case 6:maze.square[8][8] = 's';break;}//随机⽣成终点'e'表⽰while (index = rand()%36+1){//出⼝在顶部if (index >1 &&index<10 && maze.square[1][index-1]!='s'){maze.square[0][index-1] = 'e';break;}//出⼝在右侧else if (index>10 &&index <19){if (maze.square[index-10][8] != 1 && maze.square[index-10][8]!='s') {maze.square[index-10][9] = 'e';break;}}//底部出⼝else if (index >19&&index<28){if (maze.square[8][index - 19] != 's' && maze.square[8][index - 19] != 1) {maze.square[9][index - 19] = 'e';break;}}//左侧出⼝else if (index >28 && index <=36){if (maze.square[index-28][1] != 1 &&maze.square[index-28][1] != 's'){maze.square[index - 28][0] = 'e';break;}}}void showMaze(Maze maze) {for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (maze.square[i][j] == 1){cout << "* ";}else if (maze.square[i][j] == 0){cout << " ";}else{cout << (char)maze.square[i][j]<<" ";}}cout << endl;}}//寻找迷宫路径void findWay(Maze &maze,SqStack &s) {//⾸先遍历找出起始点和终点并保存下来Pos start,end;for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++) {if (maze.square[i][j] == 's'){ //起点压⼊栈内start.x = i;start.y = j;push(s, start);}else if (maze.square[i][j] == 'e'){ //出⼝end.x = i;end.y = j;}}}//寻找路径Pos go = start;//直到找到出⼝才结束while ( s.top->x != end.x || s.top->y != end.y){//获得下⼀步坐标Pos path = isExit(go, maze);if (path.x != go.x || path.y != go.y){//前进maze.square[path.x][path.y] = 'p';push(s, path);go = path;}//如果所有放向都⾛不通(即返回的点是传⼊的点),则将其标为“@”,出栈到上⼀个点,继续判断else{//⾛不通popmaze.square[path.x][path.y] = '@';pop(s);go = *s.top;}}maze.square[end.x][end.y] = 'e';}//判断返回下⼀步路径(顺序:右下左上),传⼊所处位置,从右边开始判断是否⼜通路或者出⼝,有就返回哪个⽅向上的点Pos isExit(Pos p,Maze maze) {Pos tempP = p;if (maze.square[tempP.x][tempP.y+1] == 0 || maze.square[tempP.x][tempP.y + 1] == 'e'){tempP.y++;else if(maze.square[tempP.x+1][tempP.y] == 0 || maze.square[tempP.x +1][tempP.y] == 'e'){tempP.x++;}else if (maze.square[tempP.x][tempP.y - 1] == 0 || maze.square[tempP.x][tempP.y - 1] == 'e'){tempP.y--;}else if (maze.square[tempP.x - 1][tempP.y] == 0 || maze.square[tempP.x - 1][tempP.y] == 'e'){tempP.x--;}return tempP;}三、main函数调⽤int main(){while (true){//创建⼀个迷宫Maze maze;initMaze(maze);//初始化⼀个栈SqStack S;initStack(S);cout << "*****************************" << endl;cout << "* 1、⽣成迷宫 2、退出 *" << endl;cout << "*****************************" << endl;cout << "请输⼊你的选择:";int select = 0;cin >> select;if (select == 1){cout << "⽣成随机起点和出⼝迷宫:" << endl;showMaze(maze);cout << "⽣成迷宫路径:" << endl;findWay(maze, S);stackTravel(S);showMaze(maze);cout << endl;}if (select == 2){clearStack(S);break;}}return 0;}四、评价这是个叫简易的迷宫,但基本实现了迷宫的寻路逻辑,可改进的地⽅有:1、因为很多地⽅写死了,所以复⽤性不⾼,可以⽤循环遍历来随机⽣成起点,同理迷宫的⽣成也是这样2、判断路径可以⽤递归调⽤实现前进逻辑以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

C语言实验:迷宫问题(搜索,C语言实现栈、队列)

C语言实验:迷宫问题(搜索,C语言实现栈、队列)

C语⾔实验:迷宫问题(搜索,C语⾔实现栈、队列)Description给定迷宫起点和终点,寻找⼀条从起点到终点的路径。

(0,1)(2,0)起点(1,1)(1,2)(1,3)(1,4)(2,0)(2,1)(2,4)(3,0)(3,1)(3,2)终点(3,4)(4,1)上图中黄⾊代表墙,⽩⾊代表通路,起点为(1,1),终点为(3,4)。

要求搜寻策略是从起点开始按照“上、下、左、右”四个⽅向寻找终点,到下⼀个点继续按照“上、下、左、右”四个⽅⾯寻找,当该结点四个⽅向都搜寻完,但还没到终点时,退回到上⼀个点,直到找到终点或者没有路径。

⽐如上图从(1,1)开始,向上(0,1)不通,向下到(2,1);到了(2,1)后继续按“上、下、左、右”四个⽅⾯寻找,上已经⾛过,向下到(3,1);到(3,1)后上已经⾛过,下和左不通,向右到(3,2);到(3,2)四个⽅⾯都不通,回到(3,1)四个⽅向都不通,再回到(2,1),(1,1);到达(1,1)后下已经⾛过,左不通,继续向右⾛,重复这个过程最后到达(3,4)。

Input第⼀⾏两个数m和n表⽰迷宫的⾏数和列数。

迷宫⼤⼩不超过100×100第⼆⾏四个数x1,y1,x2,y2分别表⽰起点和终点的坐标。

接下来是m⾏n列的数,⽤来表⽰迷宫,1表⽰墙,0表⽰通路。

Output从起点到终点所经过的路径的坐标。

如果不存在这样的路径则输出“No Path!”。

Sample Input5 61 1 3 41 1 1 1 1 11 0 0 0 0 11 0 1 1 0 11 0 0 1 0 11 1 1 1 1 1Sample Output(1 1)(1 2)(1 3)(1 4)(2 4)(3 4)1.思路:(1)若当前点是终点,dfs函数返回1;(2)若不是终点,将此点标记为1,对该点4个⽅向进⾏搜索,实现⽅式为定义int dir[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} }; 通过⼀个⼩循环: for(int i = 0; i < 4; i++) {  position nextp; nextp.x = dir[i][0] + now.x;nextp.y = dir[i][1] + now.y;...... } 进⾏搜索;若该点的下⼀个点nextp不是墙,未⾛,并且没有超界则将nextp压⼊栈中,递归调⽤dfs,若此过程经过(1)判断返回了1,说明最终找到了通往终点的路,便可以返回1,结束函数,此时栈中已储存了通往终点的路径,若没有通路,则弹出栈顶元素,根据递归原理该路径上的所有点都会弹出并标记未⾛,回溯到之前的点,继续向其他⽅向搜索,直到找到终点或遍历完整个图。

数据结构C语言版__递归求解迷宫问题

数据结构C语言版__递归求解迷宫问题
printf("\n");
}
printf("\n");
}
// 由当前位置cur、当前步骤curstep试探下一点
void Try(struct PosType cur,int curstep)
{
int i;
struct PosType next; // 下一个位置
// {行增量,列增量}
};
#define MAXLENGTH 25 // 设迷宫的最大行列为25
typedef int MazeType[MAXLENGTH][MAXLENGTH]; // [行][列]
// 全局变量
struct PosType end; // 迷宫终点位置
MazeType m; // 迷宫数组
1 2
迷宫结构如下:
0 0 0 0
0 -1 0 0
0 -1 -1 0
0 0 0 0
请输入起点的行数,列数:(空格隔开)1 1
请输入终点的行数,列数:(空格隔开)2 2
0 0 0 0
0 1 0 0
0 2 3 0
0 0 0 0
}
printf("迷宫结构如下:\n");
Print(x,y);
printf("请输入起点的行数,列数:(空格隔开)");
scanf("%d%d",&begin.x,&begin.y);
printf("请输入终点的行数,列数:(空格隔开)");
scanf("%d%d",&end.x,&end.y);

求解迷宫问题 (c语言

求解迷宫问题 (c语言

求迷宫问题就是求出从入口到出口的路径。

在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走;否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。

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

首先用如图3.3所示的方块图表示迷宫。

对于图中的每个方块,用空白表示通道,用阴影表示墙。

所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。

为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图3.3所示的迷宫,对应的迷宫数组mg如下:int mg[M+1][N+1]={ /*M=10,N=10*/{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{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} }; 伪代码:c语言描述如下:6/ 2void mgpath() /*路径为:(1,1)->(M-2,N-2)*/{int i,j,di,find,k;top++; /*初始方块进栈*/Stack[top].i=1;Stack[top].j=1;Stack[top].di=-1;mg[1][1]=-1;while (top>-1) /*栈不空时循环*/{i=Stack[top].i;j=Stack[top].j;di=Stack[top].di;if (i==M-2 && j==N-2) /*找到了出口,输出路径*/ {瀠楲瑮?迷宫路径如下:\n);for (k=0;k<=top;k++){printf(\ (%d,%d),Stack[k].i,Stack[k].j); if ((k+1)%5==0) printf(\);}6/ 3printf(\);return;}find=0;while (di<4 && find==0) /*找下一个可走方块*/ { di++;switch(di){case 0:i=Stack[top].i-1;j=Stack[top].j;break;case 1:i=Stack[top].i;j=Stack[top].j+1;break;case 2:i=Stack[top].i+1;j=Stack[top].j;break;case 3:i=Stack[top].i;j=Stack[top].j-1;break;}6/ 4if (mg[i][j]==0) find=1;}if (find==1) /*找到了下一个可走方块*/{Stack[top].di=di; /*修改原栈顶元素的di值*/ top++; /*下一个可走方块进栈*/Stack[top].i=i;Stack[top].j=j;Stack[top].di=-1;mg[i][j]=-1; /*避免重复走到该方块*/}else /*没有路径可走,则退栈*/{ mg[Stack[top].i][Stack[top].j]=0;/*让该位置变为其他路径可走方块*/top--;}}牰湩晴尨没有可走路径!\n);}6/ 5(范文素材和资料部分来自网络,供参考。

数据结构C语言版 非循环顺序队列求解迷宫问题

数据结构C语言版 非循环顺序队列求解迷宫问题

数据结构C语言版非循环顺序队列求解迷宫问题利用非循环顺序队列采用广度搜索法求解迷宫问题(一条路径)编译环境:Dev-C++ 4.9.9.2日期:2011年2月12日*/#include <stdio.h>#include <malloc.h>#define M 5 // 迷宫行数(包括外墙)#define N 5 // 迷宫列数(包括外墙)#define D 4 // 移动方向数,只能取4和8。

(8个,可斜行;4个,只可直走)// 移动数组,移动方向由正东起顺时针转struct{int x,y;#if D==8}move[D]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}}; #endif#if D==4}move[D]={{0,1},{1,0},{0,-1},{-1,0}};#endif// 定义栈元素类型和队列元素类型,两者为相同类型。

typedef struct{int x,y; // 当前点的行值,列值int pre; // 前一点在队列中的序号} SElemType, QElemType;#define STACK_INIT_SIZE 10 // 存储空间初始分配量#define STACKINCREMENT 2 // 存储空间分配增量// 栈的顺序存储表示 P46typedef struct SqStack{SElemType *base; // 在栈构造之前和销毁之后,base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间,以元素为单位}SqStack; // 顺序栈// 顺序队列(非循环,因为是非循环的,所以需要判断是否溢出#define MAXQSIZE 5 // 最大队列长度(对于循环队列,最大队列长度要减1) typedef struct{QElemType *base;// 初始化的动态分配存储空间相当于一个数组// 头指针,若队列不空,指向队列头元素,相当于一个数组下标int front;// 尾指针,若队列不空,指向队列尾元素的下一个位置相当于一个数组下标int rear;}SqQueue;// 构造一个空队列Qint InitQueue(SqQueue *Q){//分配定长的空间,相当于一个数组(*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));if(!(*Q).base) // 存储分配失败exit(0);(*Q).front=(*Q).rear=0; //初始化下标return 1;}// 销毁队列Q,Q不再存在int DestroyQueue(SqQueue *Q){if((*Q).base)free((*Q).base);(*Q).base=NULL;(*Q).front=(*Q).rear=0;return 1;}// 若队列Q为空队列,则返回1,否则返回0int QueueEmpty(SqQueue Q){if(Q.front==Q.rear) // 队列空的标志return 1;else}// 插入元素e为Q的新的队尾元素int EnQueue(SqQueue *Q,QElemType e){if((*Q).rear>=MAXQSIZE){ // 队列满,增加1个存储单元(*Q).base=(QElemType *)realloc((*Q).base,((*Q).rear+1)*sizeof(QElemType));if(!(*Q).base) // 增加单元失败return 0;}*((*Q).base+(*Q).rear)=e;(*Q).rear++;return 1;}// 若队列不空,则删除Q的队头元素,用e返回其值,并返回1,否则返回0int DeQueue(SqQueue *Q,QElemType *e){if((*Q).front==(*Q).rear) // 队列空return 0;*e=(*Q).base[(*Q).front];(*Q).front=(*Q).front+1;return 1;}// 构造一个空栈S。

C语言解决迷宫求解问题

C语言解决迷宫求解问题
0110000110100111001011000迷宫的路径为括号内的内容分别表示为行坐标列坐标数字化方向即方向方向111212221321422431532542550迷宫路径探索成功
迷宫求解
任务:
可以输入一个任意大小的迷宫数据,用非递归的方法求出一条走出迷宫的路
径,并将路径输出。
#include<iostream>
//获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈,则把上一个探索的位置存入栈 p
for(loop=0;loop<4;loop++) //探索当前位置的 4 个相邻位置
//使栈顶元素出栈
T GetPop();
//取出栈顶元素
void Clear();
//把栈清空
bool empty();
//判断栈是否为空,如果为空则返回 1,否则返回 0
};
Stack::Stack()
//构造函数,置空栈
{
top=NULL;
}
Stack::~Stack()
//析构函数
{
}
void Stack::Push(T e)
//输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t;
//定义一个栈,按从入口到出口存取路径
int a,b;
T data;

c语言课程设计迷宫问题

c语言课程设计迷宫问题

c语言课程设计 迷宫问题一、课程目标知识目标:1. 学生能够理解并掌握C语言中的基本语法,如变量定义、数据类型、运算符、控制语句等;2. 学生能够运用数组解决二维迷宫问题,理解数组在存储空间中的应用;3. 学生能够掌握递归算法的基本原理,并将其应用于迷宫问题的解决。

技能目标:1. 学生能够运用C语言编写简单的程序,解决迷宫问题,培养编程解决问题的能力;2. 学生能够通过分析迷宫问题,培养逻辑思维和问题分解能力;3. 学生能够运用所学知识,调试并优化迷宫问题的解决方案。

情感态度价值观目标:1. 学生在解决迷宫问题的过程中,培养面对困难时的耐心和毅力,增强解决问题的信心;2. 学生通过团队协作,学会与他人沟通、分享和合作,培养团队精神;3. 学生能够认识到编程在解决实际问题中的价值,激发对计算机科学的兴趣。

课程性质:本课程为C语言程序设计课程,通过迷宫问题引导学生运用所学知识解决实际问题。

学生特点:学生已具备一定的C语言基础,具有一定的逻辑思维能力和编程能力。

教学要求:教师应引导学生通过实践探索,掌握迷宫问题的解决方法,注重培养学生的编程技能和团队协作能力。

在教学过程中,将目标分解为具体的学习成果,以便进行教学设计和评估。

二、教学内容本课程教学内容紧密围绕课程目标,结合课本相关章节,具体安排如下:1. C语言基础语法回顾:变量定义、数据类型、运算符、控制语句(选择、循环)等,对应教材第1-3章;- 课堂讲解:10分钟;- 实践操作:20分钟。

2. 数组的应用:介绍二维数组在迷宫问题中的应用,对应教材第4章;- 课堂讲解:15分钟;- 实践操作:25分钟。

3. 递归算法:讲解递归的基本概念及其在迷宫问题中的应用,对应教材第6章;- 课堂讲解:20分钟;- 实践操作:30分钟。

4. 迷宫问题解决方案:结合前面所学知识,设计并实现迷宫问题的解决方案;- 课堂讲解:10分钟;- 实践操作:40分钟。

5. 团队协作与项目实践:分组进行迷宫问题的编程实践,培养学生的团队协作能力和编程技能;- 实践操作:2课时。

C语言数据结构之迷宫问题

C语言数据结构之迷宫问题

C语⾔数据结构之迷宫问题本⽂实例为⼤家分享了数据结构c语⾔版迷宫问题栈实现的具体代码,供⼤家参考,具体内容如下程序主要参考⾃严蔚敏⽼师的数据结构c语⾔版,在书中程序的⼤体框架下进⾏了完善。

关于迷宫问题的思路可查阅原书。

#include<iostream>using namespace std;#define MAXSIZE 10typedef int Status;typedef struct{int x;int y;}Postype;typedef struct{int ord;Postype seat;int dir;}SElemType;//栈的元素类型typedef struct{//SElemType data[MAXSIZE];SElemType* top;SElemType* base;}Stack;//栈的结构类型typedef struct{char arr[MAXSIZE][MAXSIZE];}MAZETYPE;//迷宫结构体MAZETYPE maze;void InitMaze(){maze.arr[0][0] = maze.arr[0][1] = maze.arr[0][2] = maze.arr[0][3] = maze.arr[0][4] = maze.arr[0][5] = maze.arr[0][6] = maze.arr[0][7] = maze.arr[0][8] = maze.arr[0][9] = '1'; maze.arr[1][0] = maze.arr[1][3] = maze.arr[1][7] = maze.arr[1][9] = '1';maze.arr[1][1] = maze.arr[1][2] = maze.arr[1][4] = maze.arr[1][5] = maze.arr[1][6] = maze.arr[1][8] = '0';maze.arr[2][0] = maze.arr[2][3] = maze.arr[2][7] = maze.arr[2][9] = '1';maze.arr[2][1] = maze.arr[2][2] = maze.arr[2][4] = maze.arr[2][5] = maze.arr[2][6] = maze.arr[2][8] = '0';maze.arr[3][0] = maze.arr[3][5] = maze.arr[3][6] = maze.arr[3][9] = '1';maze.arr[3][1] = maze.arr[3][2] = maze.arr[3][3] = maze.arr[3][4] = maze.arr[3][7] = maze.arr[3][8] = '0';maze.arr[4][0] = maze.arr[4][2] = maze.arr[4][3] = maze.arr[4][4] = maze.arr[4][9] = '1';maze.arr[4][1] = maze.arr[4][5] = maze.arr[4][6] = maze.arr[4][7] = maze.arr[4][8] = '0';maze.arr[5][0] = maze.arr[5][4] = maze.arr[5][9] = '1';maze.arr[5][1] = maze.arr[5][2] = maze.arr[5][3] = maze.arr[5][5] = maze.arr[5][6] = maze.arr[5][7] = maze.arr[5][8] = '0';maze.arr[6][0] = maze.arr[6][2] = maze.arr[6][6] = maze.arr[6][9] = '1';maze.arr[6][1] = maze.arr[6][3] = maze.arr[6][4] = maze.arr[6][5] = maze.arr[6][7] = maze.arr[6][8] = '0';maze.arr[7][0] = maze.arr[7][2] = maze.arr[7][3] = maze.arr[7][4] = maze.arr[7][6] = maze.arr[7][9] = '1';maze.arr[7][1] = maze.arr[7][5] = maze.arr[7][7] = maze.arr[7][8] = '0';maze.arr[8][0] = maze.arr[8][1] = maze.arr[8][9] = '0';maze.arr[8][2] = maze.arr[8][3] = maze.arr[8][4] = maze.arr[8][5] = maze.arr[8][6] = maze.arr[8][7] = maze.arr[8][8] = '0';maze.arr[9][0] = maze.arr[9][1] = maze.arr[9][2] = maze.arr[9][3] = maze.arr[9][4] = maze.arr[9][5] = maze.arr[9][6] = maze.arr[9][7] = maze.arr[9][8] = maze.arr[9][9] = '1'; }Status initStack(Stack &s){s.base = (SElemType*)malloc(MAXSIZE*sizeof(SElemType));if (!s.base) return 0;s.top = s.base;return 1;}void Push(Stack &s, SElemType e){*s.top++ = e;}void Pop(Stack &s, SElemType &e){e = *--s.top;}Status StackEmpty(Stack &s){if (s.top == s.base) return 1;else return 0;}Status Pass(Postype curpos){if (maze.arr[curpos.x][curpos.y] == '0')return 1;else return 0;}void Foot(Postype curpos){maze.arr[curpos.x][curpos.y] = '*';}void MarkPrint(Postype curpos){maze.arr[curpos.x][curpos.y] = '!';}Status StructCmp(Postype a, Postype b){if (a.x = b.x&&a.y == b.y) return 1;else return 0;}//下⼀个位置Postype NextPos(Postype CurPos, int Dir){Postype ReturnPos;switch (Dir){case 1:ReturnPos.x = CurPos.x;ReturnPos.y = CurPos.y + 1;break;case 2:ReturnPos.x = CurPos.x + 1;ReturnPos.y = CurPos.y;break;case 3:ReturnPos.x = CurPos.x;ReturnPos.y = CurPos.y - 1;break;case 4:ReturnPos.x = CurPos.x - 1;ReturnPos.y = CurPos.y;break;}return ReturnPos;}Status MazePath(Postype start, Postype end) {Stack s;SElemType e;initStack(s);Postype curpos = start;int curstep = 1;do{if (Pass(curpos)){Foot(curpos);e = { curstep, curpos, 1 };Push(s, e);if (StructCmp(curpos, end)) return 1;curpos = NextPos(curpos, 1);curstep++;}else{if (!StackEmpty(s)){Pop(s, e);while (e.dir ==4 &&!StackEmpty(s)){MarkPrint(e.seat); Pop(s, e);}if (e.dir < 4 && !StackEmpty(s)){e.dir++;Push(s, e);curpos = NextPos(e.seat, e.dir);}}}} while (!StackEmpty(s));return 0;}int main(){InitMaze();Postype s, e;s.x = s.y = 1;e.x = e.y = 8;if (MazePath(s, e))printf("迷宫成功解密!\n");elseprintf("解密失败\n");for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){printf("%c ", maze.arr[i][j]);}printf("\n");}cout << "-=================================" << endl;for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (maze.arr[i][j] == '*' || maze.arr[i][j] == '!')printf("%c ", maze.arr[i][j]);else cout << " ";}printf("\n");}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

(完整word版)迷宫(C语言版)--数据结构课程设计

(完整word版)迷宫(C语言版)--数据结构课程设计

一.迷宫问题求解1.问题描述迷宫问题是实验心理学的一个经典问题,心理学家把一只老鼠从一个无顶盖的大盒子的入口出赶迷宫。

迷宫中设置了很多隔壁,对前进方向形成了多出障碍,心理学家在迷宫的唯一出口处放置了一块奶酪,吸引老鼠在迷宫中寻找路径以到达出口。

然而,用计机模拟迷宫问题,即划好迷宫的隔壁的设置,让计算机从入口处进入迷宫探究出一条通路。

2.设计思路回溯法是一种不断试探且及时纠正错误的探索方法。

下面的求解过程既是使用回溯法。

从入口出发,按某一个方向向前探索,若能走通并且未走过,即某处可以到达,则到达新点,否则试探下一个方向;若所有的方向均没有通路,则沿原路返回前一个点,换下一个方向继续探索,直到找到一条通路,或无路可走又返回到入口点。

在求解过程中,为了保证在到达某一点后不能向前继续行走(无路)时,能正确返回前一个点以便继续从下一个方向向前试探,则需要用一个栈保存所有到达点的下标。

另外,求解该问题的一个重要问题是如何防止回溯时走重复节点,以避免发生死循环。

这里,我们采用对走过的结点,修改其结点信息。

如在设计之初,我们设置保存迷宫结构的二维数组中0值代表该节点可走,1值代表其不可走,那么我们可以把走过的结点值改为非0,已使其不能被再次探索。

3.数据结构设计由上面的设计思路知,若想正确的使用回溯法求解迷宫问题,必须要借助一个栈以保存走过的结点信息。

而这里我活用了栈,只把其数据结构抽象为了一个结构体数组,具体设计如下:typedef struct{int x,y; /*记录迷宫结点的位置信息*/}pos;pos Pos[100]; /*结构体数组以保存走过的结点信息*/4.功能函数介绍(1)判断是否找到出口函数Isover();该函数的参数是当前结点的x、y坐标与出口结点的x、y坐标,通过比较其值来判断是否找到出口结点,从而控制程序结束。

(2)对程序相关信息的简单介绍函数introduce();该函数主要是在进行绘制迷宫的图形化界面之前开发者搞的一点小插曲,以介绍跟该程序的相关的部分信息。

数据结构(C语言)迷宫问题

数据结构(C语言)迷宫问题
#define OVERFLOW -2
typedef int Status; //函数的返回值
typedef int DirectiveType; //下一个通道方向
#define RANGE 100 //迷宫大小
//~
2。
//stack.h
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define COL 8 //迷宫的列数
typedef struct...{
int m,n;
int arr[RANGE][RANGE];
}MazeType; //迷宫类型
Status InitMaze(MazeType &maze, int a[][COL], int row, int col)...{
#include<stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#definBiblioteka OK 1#define ERROR 0
#define INFEASIBLE -1
if(s.top-s.base >= s.stacksize)...{ //栈满,追加存储空间
s.base = (SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s.base) exit(OVERFLOW);

用栈求解迷宫问题所有路径及最短路径程序c语言

用栈求解迷宫问题所有路径及最短路径程序c语言

用栈求解迷宫问题所有路径及最短路径程序c语言
摘要:
1.迷宫问题的背景和意义
2.栈的基本概念和原理
3.用栈解决迷宫问题的方法
4.C 语言编程实现步骤
5.程序示例及运行结果
正文:
【1.迷宫问题的背景和意义】
迷宫问题是计算机科学中的一个经典问题,它涉及到图论、数据结构和算法等多个领域。

在迷宫问题中,给定一个有向图,目标是找到从起点到终点的所有路径以及最短路径。

这个问题在现实生活中也有很多应用,例如地图导航、物流路径规划等。

【2.栈的基本概念和原理】
栈是一种线性数据结构,它遵循后进先出(LIFO)的原则。

栈可以用来存储序列中的元素,也可以用来表示函数调用关系。

栈的操作通常包括入栈、出栈、获取栈顶元素等。

【3.用栈解决迷宫问题的方法】
为了解决迷宫问题,我们可以使用栈来记录遍历过程中的路径。

具体步骤如下:
1.创建一个栈,用于存储遍历过程中的路径;
2.从起点开始,将当前节点的编号入栈;
3.遍历当前节点的所有相邻节点,如果相邻节点未被访问过,则将其入栈;
4.当栈不为空时,继续执行步骤3;否则,说明已到达终点,开始回溯,找到最短路径;
5.从栈顶弹出节点,将其添加到结果路径列表中;
6.如果栈为空,说明没有找到从起点到终点的路径;否则,返回结果路径列表。

数据结构编程《迷宫问题》

数据结构编程《迷宫问题》
} if(arr[cur.x][cur.y+1]==0) //南 {
Point t; t.x =cur.x; t.y=cur.y+1; if(next(arr,t,end)) return 1;
} … //西 …//北 arr[cur.x][cur.y] = 1; return 0; }
3.非递归 算法
else if (arr[P.x-1][P.y]==0) arr[--P.x][P.y] = 2;
else
{
P = PointStack.Pop();
arr[P.x][P.y] = 1;
P = PointStack.Pop();
}
辅助函数
单击此处可添加副标题
//打印迷宫 void PrintPath(int arr[][10]) { for (int i=0;i<10;i++) { for (int j=0;j<10;j++) { if (arr[i][j]==-1) cout<<"■"; else if (arr[i][ j]==2) cout<<" *"; else cout<<"□"; } cout<<endl; } cout<<endl; }
迷宫求解
每走一步:
1. 如果当前位置=出口,结束 2. 否则:
① 假设当前位置为路径; ② 如果东面未走过:向东走一步 ③ 如果南面未走过:向南走一步 ④ 如果西面未走过:向西走一步 ⑤ 如果北面未走过:向北走一步 ⑥ 设置当前位置走不通,回溯
int next(int arr[][10],Point cur,Point end) {

(完整word版)数据结构C语言迷宫求解问题(有要求和源代码)

(完整word版)数据结构C语言迷宫求解问题(有要求和源代码)

1、迷宫求解设计一个迷宫求解程序,要求如下:✓以M × N表示长方阵表示迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

✓能任意设定的迷宫✓(选作)如果有通路,列出所有通路提示:✓以一个二维数组来表示迷宫,0和1分别表示迷宫中的通路和障碍,如下图迷宫数据为:1111111111 Array 100100010110010001011000011001101110000110001000011010001001101110110111000000011111111111入口位置:1 1出口位置:8 8✓探索过程可采用如下算法,设定当前位置的初值为入口位置;do {若当前位置可通,则{将当前位置插入栈顶;若该位置是出口位置,则结束;否则切换当前位置的东邻方块为新的当前位置;}否则,{若栈不空且栈顶位置尚有其他方向未经探索,则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块;若栈不空但栈顶位置的四周均不可通,则{删去栈顶位置;//从路径中删去该通道块若栈不空,则重新测试新的栈顶位置,直至找到一个可通的相邻块出栈至栈空;}}}while (栈不空);#include<stdio.h>#include<string.h>#define MaxSize 32int a[30][30];int b[30][30];int m,n;typedef struct{int i;int j;int di;}Box;typedef struct{Box data[MaxSize];int top;}StackType;bool sereach(int X,int Y,int X1,int Y1);void main(){int X,Y,Y1,X1;memset(a,0,sizeof(a));memset(b,0,sizeof(b));// for()printf("请输入迷宫的长度和宽度\n");while(~scanf("%d%d",&m,&n)){printf("请输入迷宫(0表示空地,1表示围墙)\n");for(int i=0;i<n;i++){for(int j=0;j<m;j++){scanf("%d",&a[i][j]);if(a[i][j]==1)b[i][j]=-1;}}printf("请输入迷宫起点的行号和列号\n");scanf("%d%d",&X,&Y);printf("请输入迷宫终点的行号和列号\n");scanf("%d%d",&X1,&Y1);if(!sereach(X,Y,X1,Y1))printf("该迷宫没有解!\n");printf("请输入迷宫的长度和宽度\n");}// return 0;}bool sereach(int X,int Y,int X1,int Y1){StackType st;int i,j,di,find;st.top=-1;while(a[X][Y]!=0){printf("迷宫起点的行号和列号有错,请重新输入\n");scanf("%d%d",&X,&Y);}if(a[X][Y]==0)b[X][Y]=-1;while(a[X1][Y1]!=0){printf("迷宫终点的行号和列号有错,请重新输入\n");scanf("%d%d",&X1,&Y1);}st.top++;st.data[st.top].i=X;st.data[st.top].j=Y;st.data[st.top].di=-1;do{find=0;i=st.data[st.top].i;j=st.data[st.top].j;di=st.data[st.top].di;while(di<4&&find==0){di++;switch(di){case 0:i=st.data[st.top].i-1;j=st.data[st.top].j;break;case 1:i=st.data[st.top].i;j=st.data[st.top].j+1;break;case 2:i=st.data[st.top].i+1;j=st.data[st.top].j;break;case 3:i=st.data[st.top].i;j=st.data[st.top].j-1;break;}if(b[i][j]==0&&i>=0&&i<n&&j>=0&&j<m)find=1;}if(find == 1){st.data[st.top].di=di;st.top++;st.data[st.top].i=i;s t.data[st.top].j=j;st.data[st.top].di=-1;b[i][j]=-1;find=0;}else{b[st.data[st.top].i][st.data[st.top].j]=0;st.top--;}if(i==X1&&j==Y1){printf("迷宫路径如下:\n");for(int k=0;k<=st.top;k++){printf("%d,%d\t",st.data[k].i,st.data[k].j);if((k+1)%6==0)printf("\n");}printf("\n");。

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

#include <stdio.h>#include <stdlib.h>#include <time.h>#define M 20#define N 20#define visited 2#define TRUE 1#define FALSE 0#define INITSIZE 100typedef int Status;typedef struct{ //坐标点结构体int y; //每个可通的行坐标int x; //每个可通的列坐标}PosType;typedef struct{int ord; //通道块在路径上的“序号”int di; //从此通道块走向下一通道块的“方向”PosType seat; //通道块在迷宫中的“坐标位置”}MazeNode; //迷宫节点typedef struct {MazeNode base[INITSIZE];int top; //栈顶指针}Stack;typedef struct{ //用于存储迷宫的路径PosType coor[INITSIZE];int top;}Postion;void RandMatrix(); //随机生成迷宫int InitStack(Stack *); //初始化栈int InitStack1(Postion *);int StackEmpty(Stack *); //判断栈是否为空int StackEmpty1(Postion *);int StackIsFull(Stack *); //判断栈是否满了int StackIsFull1(Postion *); //判断栈是否满了int Push(Stack *s,MazeNode m); //压栈int Push1(Postion *,PosType);int Pop(Stack *s,MazeNode *m); //出栈int Pop1(Postion *,PosType *);int DestroyStack(Stack *s); //撤销栈int Pass(PosType pos); //判断指定坐标是否可通过int FootPrint(PosType pos); //标记能通过的PosType NextCoord(PosType pos,int i); //获取下一位置int MarkPrint(PosType pos); //留下不能通过的标记,并退回一步int MazePath(PosType start,PosType end,Postion *); //从迷宫的入口到出口查找void PrintMaze(Postion *); //输出迷宫int mg[M][N]; //生成一个M*N 的迷宫int main(){int h=1;PosType start,end;Postion P;while(h){printf("创建迷宫\n");InitStack1(&P);RandMatrix();printf("\n");printf("1、重新生成迷宫,0、就这个:");scanf("%d",&h);}do //输入迷宫入口坐标{printf("\n输入迷宫入口坐标");scanf("%d%d",&start.x,&start.y);if(start.x>N || start.y>M){printf("输入的坐标越界,请重新输入!\n");continue;}}while(start.x>N || start.y>M);do //输入迷宫出口坐标{printf("\n输入迷宫出口坐标:");scanf("%d%d",&end.x,&end.y);if(end.x>N || end.y>M){printf("输入的坐标越界,请重新输入!\n");continue;}}while(end.x>N || end.y>M);if(!MazePath(start,end,&P)) //调用函数查找路径{printf("\n无法通过!\n");}else{PrintMaze(&P); //打印找到的路径}return 0;}int InitStack(Stack *s){s->top=-1;return 1;}int InitStack1(Postion *s){s->top=-1;return 1;}int StackEmpty(Stack *s){if(s->top==-1)return 1;return 0;}int StackEmpty1(Postion *s){if(s->top==-1)return 1;return 0;}int StackIsFull(Stack *s){if(s->top==INITSIZE-1)return 1;elsereturn 0;}int StackIsFull1(Postion *s){if(s->top==INITSIZE-1)return 1;elsereturn 0;}int Push(Stack *s,MazeNode m) {if(!StackIsFull(s)){s->top++;s->base[s->top]=m;}return 1;}int Push1(Postion *s,PosType m) {if(!StackIsFull1(s)){s->top++;s->coor[s->top]=m;}return 1;}int Pop(Stack *s,MazeNode *m) {if(s->top!=-1){*m=s->base[s->top];s->top--;return 1;}return 1;}int Pop1(Postion *s,PosType *m) {if(s->top!=-1){*m=s->coor[s->top];s->top--;return 1;}return 1;}int DestroyStack(Stack *s){s->top=-1;return 1;}int Pass(PosType pos) //判断指定坐标是否可通过{if(mg[pos.y][pos.x]==0) //可通return 1;elsereturn 0;}int FootPrint(PosType pos) //标记能通过的{mg[pos.y][pos.x]=2; //2表示可通return 1;}PosType NextCoord(PosType pos,int i) //获取下一位置{switch(i) //1,2,3,4,5,6,7,8代表方向顺时针{case 1:pos.x+=1; //向右侧查找break;case 2:pos.x+=1;pos.y+=1;break;case 3:pos.y+=1;break;case 4:pos.y+=1;pos.x-=1;break;case 5:pos.x-=1;break;case 6:pos.x-=1;pos.y-=1;break;case 7:pos.y-=1;break;case 8:pos.y-=1;pos.x+=1;break;default :exit(0);}return pos;}int MarkPrint(PosType pos) //留下不能通过的标记,并退回一步{mg[pos.y][pos.x]=3; //3表示曾走过,但不通return 1;}void RandMatrix(){int i=0,j=0;srand((unsigned)time(NULL));for(i=0;i<M;i++)for(j=0;j<N;j++)mg[i][j]=rand()%2;i=0;for(j=0;j<N;j++){mg[i][j]=1;mg[j][i]=1;}i=N-1;for(j=0;j<M;j++){mg[j][i]=1;mg[i][j]=1;}mg[1][1]=0;mg[M-2][N-2]=0;printf("\n");for(i=0;i<M;i++){for(j=0;j<N;j++){if(mg[i][j]==1) //若是障碍{printf("█");}else if(mg[i][j]==2) //若是可通路径{printf("◎");}else if(mg[i][j]==3){printf("☆"); //其他位置}elseprintf(" ");}printf("\n");}}int MazePath(PosType start,PosType end,Postion *P) //从迷宫的入口到出口查找{//若迷宫maze中存在从入口start到出口end的通道,则求得一条存放在栈中(从栈底到栈顶)//并返回TRUE,否则返回FALSEStack S; //定义栈PosType curpos;int curstep; //当前序号1,2,3,4,5,6,7,8代表方向,1代表向右,后依次顺时针MazeNode e;InitStack(&S);curpos=start; //设定“当前位置”为“入口位置”,从入口位置开始查找curstep=1; //探索第一步do{if(Pass(curpos)){//从当前位置可以通过,即是未曾走到过的通道块FootPrint(curpos); //标记能通过的e.ord=curstep; //保存步数e.seat=curpos;e.di=1; //向右侧探测Push(&S,e); //加入路径Push1(P,curpos);if(curpos.y==end.x && curpos.x==end.y) //若当前位置是出口坐标{DestroyStack(&S); //释放栈占用的空间return 1; //返回查找成功}else //与出口坐标不同{curpos=NextCoord(curpos,1); //向右侧探测curstep++; //探索下一步}}else //当前位置不能通过(为障碍或已走过){if(!StackEmpty(&S)) //若栈不为空,之前有走过的位置{Pop(&S,&e); //出栈(返回上一步的位置)Pop1(P,&curpos);while(e.di==8 && !StackEmpty(&S)) //上一步,四个方向都探测定,且栈不为空{MarkPrint(e.seat); //留下不能通过的标记,并退回一步Pop(&S,&e); //出栈,返回上一步Pop1(P,&curpos);}if(e.di<8){e.di++; //换下一个方向探索,准备探测下一个方向Push(&S,e); //将当前节点入栈Push1(P,curpos);curpos=NextCoord(e.seat,e.di); //设定当前位置是该新方向上的相邻块,查找下一个应该探测的方向}}}}while(!StackEmpty(&S));//程序运行到这里,表示没有能通达的路径DestroyStack(&S); //释放占用的空间return FALSE; //返回失败}void PrintMaze(Postion *P) //输出迷宫{int i,j;PosType e;Postion W;InitStack1(&W);while(!StackEmpty1(P)){Pop1(P,&e);Push1(&W,e);}printf("\n可以通过,迷宫路径:\n"); //在这里可以设置迷宫的界面for(i=0;i<M;i++){for(j=0;j<N;j++){if(mg[i][j]==1) //若是障碍{printf("█");}else if(mg[i][j]==2) //若是可通路径{printf("◎");}else if(mg[i][j]==3){printf("☆"); //其他位置}else{printf(" ");}}printf("\n");}printf("\n\n");i=1;printf("迷宫的最短路径为:");while(!StackEmpty1(&W)){i++;Pop1(&W,&e);printf("(%d,%d), ",e.y,e.x);}printf("\n\n");}。

相关文档
最新文档