您的位置：360文档中心› 数据结构 迷宫 C语言

数据结构 迷宫 C语言

合集下载

数据结构(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语言版)-源代码(直接运行)

#include <stdio.h>#include <stdlib.h>#include <string.h>#define STACK_INIT_SIZE 100#define INCREMENT 10typedef struct{int r;int c;}zuobiao;typedef struct{int ord; //在当前坐标上的“标号”zuobiao seat; //坐标int di; //走向下一通道的方向}lujing;typedef struct{int sz[10][10];}Maze;typedef struct SqStack{lujing *base;lujing *top;int size;}SqStack;int initStack(SqStack *s){s->base = (lujing *)malloc(STACK_INIT_SIZE*sizeof(lujing) );if(!s->base)return -1;s->top = s->base;s->size = STACK_INIT_SIZE;return 0;}int push(SqStack *s, lujing e){if(s->top - s->base >= s->size){s->base = (lujing *)realloc(s->base, (s->size+INCREMENT)*sizeof(lujing));if(!s->base)return -1;s->top = s->base+s->size;s->size += INCREMENT;}*s->top++ = e;return 0;}int pop(SqStack *s,lujing *e){if(s->top == s->base)return -1;*e = *(--s->top);return 0;}int isEmpty(SqStack *s){if(s->base == s->top)return 1;elsereturn 0;}int pass( Maze maze,zuobiao dqzb) {if (maze.sz[dqzb.r][dqzb.c]==1)return 1; // 如果当前位置是可以通过，返回1else return 0; // 否则返回0}void footPrint(Maze &maze,zuobiao dqzb) {maze.sz[dqzb.r][dqzb.c]=9;}void markPrint(Maze &maze,zuobiao dqzb) {maze.sz[dqzb.r][dqzb.c]=4;}zuobiao nextPos(zuobiao dqzb, int Dir) {zuobiao xzb;switch (Dir) {case 1:xzb.r=dqzb.r;xzb.c=dqzb.c+1;break;case 2:xzb.r=dqzb.r+1;xzb.c=dqzb.c;break;case 3:xzb.r=dqzb.r;xzb.c=dqzb.c-1;break;case 4:xzb.r=dqzb.r-1;xzb.c=dqzb.c;break;}return xzb;}int mazePath(Maze &maze, zuobiao start, zuobiao end){SqStack *s = (SqStack *)malloc(sizeof(SqStack));initStack(s);zuobiao dqzb = start; // 设定"当前位置"为"入口位置"lujing e;int curstep = 1; // 探索第一步do {if (pass(maze,dqzb)) { // 当前位置可通过，即是未曾走到过的通道块footPrint(maze,dqzb); // 留下足迹e.di =1;e.ord = curstep;e.seat= dqzb;push(s,e); // 加入路径if (dqzb.r == end.r && dqzb.c==end.c)return 0; // 到达终点（出口）dqzb = nextPos(dqzb, 1); // 下一位置是当前位置的东邻curstep++; // 探索下一步} else { // 当前位置不能通过if (!isEmpty(s)) {pop(s,&e);while (e.di==4 && !isEmpty(s)) {markPrint(maze,e.seat);pop(s,&e); // 留下不能通过的标记，并退回一步}if (e.di<4) {e.di++; // 换下一个方向探索push(s, e);dqzb = nextPos(e.seat, e.di); // 当前位置设为新方向的相邻块}}}} while (!isEmpty(s) );return -1;}void main(){printf(" *----Δ迷宫求解Δ----*\n\n");printf("---迷宫如下所示:（说明：0表示墙；1表示可以通过）");printf("\n");Maze maze; //声明mazemaze.sz[0][0]= 0;maze.sz[0][1]= 0;maze.sz[0][2]= 0;maze.sz[0][3]= 0;maze.sz[0][4]= 0;maze.sz[0][5]= 0;maze.sz[0][6]= 0;maze.sz[0][7]= 0;maze.sz[0][8]= 0;maze.sz[0][9]= 0;maze.sz[1][0]= 0;maze.sz[1][1]= 1;maze.sz[1][2]= 1;maze.sz[1][3]= 0;maze.sz[1][4]= 1;maze.sz[1][5]= 1;maze.sz[1][6]= 1;maze.sz[1][7]= 0;maze.sz[1][8]= 1;maze.sz[1][9]= 0;maze.sz[2][0]= 0;maze.sz[2][1]= 1;maze.sz[2][2]= 1;maze.sz[2][3]= 0;maze.sz[2][4]= 1;maze.sz[2][5]= 1;maze.sz[2][6]= 1;maze.sz[2][7]= 0;maze.sz[2][8]= 1;maze.sz[2][9]= 0;maze.sz[3][0]= 0;maze.sz[3][1]= 1;maze.sz[3][2]= 1;maze.sz[3][3]= 1;maze.sz[3][4]= 1;maze.sz[3][5]= 0;maze.sz[3][6]= 0;maze.sz[3][7]= 1;maze.sz[3][8]= 1;maze.sz[3][9]= 0;maze.sz[4][0]= 0;maze.sz[4][1]= 1;maze.sz[4][2]= 0;maze.sz[4][3]= 0;maze.sz[4][4]= 0;maze.sz[4][5]= 1;maze.sz[4][6]= 1;maze.sz[4][7]= 1;maze.sz[4][8]= 1;maze.sz[4][9]= 0;maze.sz[5][0]= 0;maze.sz[5][1]= 1;maze.sz[5][2]= 1;maze.sz[5][3]= 1;maze.sz[5][4]= 0;maze.sz[5][5]= 1;maze.sz[5][6]= 1;maze.sz[5][7]= 0;maze.sz[5][8]= 1;maze.sz[5][9]= 0;maze.sz[6][0]= 0;maze.sz[6][1]= 1;maze.sz[6][2]= 0;maze.sz[6][3]= 1;maze.sz[6][4]= 1;maze.sz[6][5]= 1;maze.sz[6][6]= 0;maze.sz[6][7]= 1;maze.sz[6][8]= 1;maze.sz[6][9]= 0;maze.sz[7][0]= 0;maze.sz[7][1]= 1;maze.sz[7][2]= 0;maze.sz[7][3]= 0;maze.sz[7][4]= 0;maze.sz[7][5]= 1;maze.sz[7][6]= 0;maze.sz[7][7]= 0;maze.sz[7][8]= 1;maze.sz[7][9]= 0;maze.sz[8][0]= 0;maze.sz[8][1]= 0;maze.sz[8][2]= 1;maze.sz[8][3]= 1;maze.sz[8][4]= 1;maze.sz[8][5]= 1;maze.sz[8][6]= 1;maze.sz[8][7]= 1;maze.sz[8][8]= 1;maze.sz[8][9]= 0;maze.sz[9][0]= 0;maze.sz[9][1]= 0;maze.sz[9][2]= 0;maze.sz[9][3]= 0;maze.sz[9][4]= 0;maze.sz[9][5]= 0;maze.sz[9][6]= 0;maze.sz[9][7]= 0;maze.sz[9][8]= 0;maze.sz[9][9]= 0;int i,j,sum;for (i = 0; i < 10; i++) {for (j = 0; j < 10; j++){printf("%4d",maze.sz[i][j]);sum++;}if(sum%10==0)printf("\n");}printf("\n");printf("---请输入1求解路径图:");int a;scanf("%d",&a);if(a==1){zuobiao rukou,chukou;rukou.r=1;rukou.c=1;chukou.r=8;chukou.c=8;mazePath(maze,rukou,chukou);printf("\n");printf("---图解如下所示:（说明：0表示墙；1表示可以通过；4表示走不通；9表示所走的路径）\n");for (i = 0; i < 10; i++) {for (j = 0; j < 10; j++){printf("%4d",maze.sz[i][j]);sum++;}if(sum%10==0)printf("\n");}}}。

数据结构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);

迷宫(direction)C语言代码

迷宫(direction)C语言代码
/* 其中 1<=x1,x2<=M-2 , 1<=y1,y2<=N-2 */
voidmazePath(intmaze[][N],intdirection[][2],intx1,inty1,intx2,inty2) {
inti, j, k, g, h;
PSeqStackst;
DataTypeelement;
1,1,1,1,1,1,1,1,1,1,1
};
mazePath(maze,direction,1,1,6,9);
getchar();
return 0;
}
#include<stdio.h>
#include<conio.h>
intmigong[10][10]= //设置迷宫，最外围1为墙 里边0为可走路径 1为障碍
find=1;
}
if(find==1){ //判断是否找得到
lj[top].d=d;
top++;
lj[top].x=x;
lj[top].y=y;
d=-1;find=0; //重新调整方向
migong[x][y]=-1;}
else{
migong[lj[top].x][lj[top].y]=0;
top--;d=lj[top].d; //找不到的话退栈
case1:x=lj[top].x; y=lj[top].y+1;break;//方向为右
case2:x=lj[top].x+1; y=lj[top].y; break;//方向为下
case3:x=lj[top].x; y=lj[top].y-1;}//方向为左
if(migong[x][y]==0)

数据结构(C语言)经典迷宫算法

数据结构(C语言)经典迷宫算法

main.h#include<stdio.h>#include<stdlib.h>#include<string.h>#include <Windows.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define N 10//#define M 82//0 通道//1 墙壁//2 走过//3 不能通过需退回//4 结果//typedefstruct //二维数组以1和0区分墙壁和通道以显示迷宫int a[N][N]; //{//intMaze[N][N];//}Maze;typedefstruct//通道块在迷宫中的坐标{int x;int y;}Pos;//压入栈的值为可通的坐标typedefstruct{//di//1上//2下//3左//4右intord;//通道块在路径上的序号Pos seat;//通道块在迷宫中的“坐标位置”int di;//从此通道块走向下一通道块的“方向”}ForStack;//栈的元素类型/*typedefstruct{Pos S;}Pstack;*/typedefstruct{ForStack *base;//在栈构造之前和销毁之后，base的值为NULLForStack *top;//栈顶指针intstacksize;//当前已分配的存储空间,以元素为单元}SqStack;//-------基本操作的函数原型-------void tips(); //操作提示void status(int status);//若出错输出出错状态intInitStack(SqStack&s);//构造一个空栈//intDestroyStack(SqStack&s);//销毁栈s,s不再存在//intClearStack(SqStack&s);//把s置为空栈intStackEmpty(SqStack s);//若栈为空返回true，非空返回falseint Push(SqStack&s,ForStack e);//插入元素e为新的栈顶元素int Pop(SqStack&s,ForStack&e);//若栈不空，则删除s的栈顶元素,用e返回其值,并返回OK否则返回falseintGetTop(SqStacks,ForStack&e);//若栈不空，用e返回S的栈顶元素//intInit(int&fa[N][N]);//初始化一个迷宫地图intMazePath(int Maze[][N], Posstart,Pos end);//完成迷宫的寻路功能void ShowMaze(intSMaze[][N],int c);//找到路径后显示迷宫PosNextPos(Posnow,int di);//下一个位置*.cpp#include "main.h"intInitStack(SqStack&s)//构造一个空栈{s.base=(ForStack*)malloc(STACK_INIT_SIZE*sizeof(ForStack));if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;return OK;}intGetTop(SqStacks,ForStack&e)//若栈不空，用e返回S的栈顶元素{if(s.top==s.base)return ERROR;e=*(s.top-1);return OK;}intStackEmpty(SqStack s)//若栈为空返回true，非空返回false{if(s.top==s.base)//若为空栈返回TRUEreturn TRUE;elsereturn FALSE;}int Push(SqStack&s,ForStack e)//插入元素e为新的栈顶元素{if((s.top-s.base)>=s.stacksize){//若栈满则追加存储空间s.base=(ForStack*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(ForStack));if(!s.base)//存储追加失败exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=e;return OK;}int Pop(SqStack&s,ForStack&e)//若栈不空，//则删除s的栈顶元素,用e返回其值,并返回OK否则返回false{if(s.top==s.base)return ERROR;e=*(--s.top);return OK;}//---------------------------------------------------------------------------PosNextPos(Posnow,int di) //下一个位置{Pos n;switch(di){case 1://上now.y-=1;break;case 2://下now.y+=1;break;case 3://左now.x-=1;break;case 4://右now.x+=1;break;}n.x=now.x;n.y=now.y;return n;}intMazePath(int Maze[][N],Posstart,Pos end) //完成寻路{SqStack S;InitStack(S);//初始化空栈SPoscurpos=start;ForStack e;intcurstep=1;do{if(Maze[curpos.x][curpos.y]==0)//当前位置可通（未曾走到过的通道块）{Maze[curpos.x][curpos.y]=2;//留下足迹e.ord=curstep;e.seat.x=curpos.x;e.seat.y=curpos.y;e.di=1;Push(S,e);//加入路径if(curpos.x==end.x&&curpos.y==end.y)//到达出口return TRUE;curpos=NextPos(curpos,1);//下一位置是当前位置的东邻curstep++;//探索下一步}else//当前位置不能通过{if(!StackEmpty(S)){Pop(S,e);while(e.di==4 && !StackEmpty(S)){Maze[e.seat.x][e.seat.y]=3;//留下不能通过的标记并退回一步Pop(S,e);}if(e.di<4)//换下一个方向继续探索{e.di++;Push(S,e);curpos=NextPos(e.seat,e.di);//设定当前位置是该新方向上的相邻块}}}}while(!StackEmpty(S));return FALSE;}void ShowMaze(intSMaze[N][N],int c)//把用二维数组表示的迷宫打印出来{if(c==1) //显示初始的{for(int i=0;i<N;i++){for(int j=0;j<N;j++){printf("%d ",SMaze[i][j]);}printf("\n");}}if(c==2) //显示寻路完成的{for(int i=0;i<N;i++){for(int j=0;j<N;j++){if(SMaze[i][j]==2)printf("* ");elseprintf("%d ",SMaze[i][j]);}printf("\n");}}}int main(){int count=0;int Maze01[N][N]={{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},};printf("\n---------------------------------迷宫---------------------------\n\n\n");ShowMaze(Maze01,1);//显示迷宫//--------printf("\n用二维数组表示迷宫\n");printf("各数值代表意义如下：\n");printf("0 通道\n1 墙\n");printf("3 特定方向下不能通过的通道块(四周至少有一块墙或走过的不通的路)\n");printf("* 最终路径\n");//-------Pos start={1,1};//入口统一设在(1,1)处,出口在(8,8)处Pos exit={8,8};MazePath(Maze01,start,exit);//完成寻路printf("\n寻路");while(count<20){printf(".");Sleep(100);count++;}printf("\n寻路完成\n");ShowMaze(Maze01,2);//显示迷宫return 0;}。

c语言迷宫问题代码实现

c语言迷宫问题代码实现
}SEAT;
structStackList
{
SEAT stack[MAXSIZE];
inttop;
}*Stack;
intEmptyStack(StackList*Stack)//判断是否为空栈
{
if(Stack->top==0)
return 0;
else
return 1;
}
intMove[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//分别表示向东、西、南、北需要加上的坐标
CurSeat=temp;
find =1;
}
}
}
}
}while(EmptyStack(Stack));
return false;
}
voidPrintStack(StackList*Stack)//输出路线
{
if(Stack->top==0)
printf("There is no route can be out of the maze\n");
Mark(CurSeat);
if(CurSeat.x==end.x+1&&CurSeat.y==end.y+1)//如果找到出口，返回
{
return true;
}
else
{
intfind=0;
while(CurSeat.di<3&&find==0)//找下一个结点的方向
{
CurSeat.di++;
SEAT temp;
scanf("%d",&n);
printf("Please enter the labyrinth of the coordinates of the wall unit(0<=row,column):\n");

c语言迷宫代码

c语言迷宫代码

c语言迷宫代码C语言迷宫代码是指用C语言编写的程序，用于生成和解决迷宫问题的算法。

迷宫通常由一个矩形网格组成，其中包含墙壁和通道。

目标是找到从迷宫的起点到终点的路径，同时避开墙壁。

下面是一个简单的示例代码，用于生成迷宫：```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define ROWS 10#define COLS 10typedef struct {int x;int y;} Point;void generateMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {if (i % 2 == 0 || j % 2 == 0) { maze[i][j] = 1; // 墙壁} else {maze[i][j] = 0; // 通道}}}}void printMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {printf('%d ', maze[i][j]);}printf('');}}int main() {int maze[ROWS][COLS];generateMaze(maze);printMaze(maze);return 0;}```在上面的代码中，我们使用一个二维数组来表示迷宫。

数组中的值为1表示墙壁，值为0表示通道。

使用generateMaze函数，我们将迷宫的墙壁和通道初始化为适当的值。

然后使用printMaze函数打印迷宫。

通过运行上面的代码，我们可以得到一个简单的迷宫的表示：```1 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 1```当然，上述代码只是生成了一个简单的迷宫，还没有解决迷宫问题。

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()；该函数主要是在进行绘制迷宫的图形化界面之前开发者搞的一点小插曲，以介绍跟该程序的相关的部分信息。

(完整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");。

数据结构迷宫算法实现c语言

数据结构迷宫算法实现c语言

数据结构迷宫算法实现c语⾔迷宫问题求解是⼀个⾮常经典的算法问题，该问题要求程序能根据⽤户的输⼊的长和宽去初始化迷宫，接着给⽤户提供两个选择，⽤户可以选择在迷宫⾥⼿动或⾃动⽣成指定个数的障碍，接着程序会⾃动找到⼀条能够从⼊⼝⾛到出⼝的路径，并且输出该路径下⾯开始分析，因为迷宫是由多个点组成的，那么要实现上述功能，我们可以定义⼀个结构体去存放每个点的横纵坐标去表⽰位置，还需要⽤到⼀个⼆维数组去存放迷宫，在迷宫⾥有三种状态，0代表通路，1代表障碍，2代表已经⾛过的路，那么可以将指定的值⼀⼀赋给数组中每个元素，迷宫⾥的点是需要⽤坐标去表⽰的，那么为了⽅便，可以将⼆维数组下标（横坐标或纵坐标）为0的点（及迷宫的外围）都设置为1（障碍），为了防⽌找路时⾛出去，⾛过的路(⾛过的每个坐标)需要⽤到⼀个栈去存放每个点，栈其实就是⼀段内存，有两个指针⼀开始都指向数组的头地址（也能理解为栈底），接着随着数据的存放，栈顶指针会跟着存放的数据移动，栈底指针不变，那么根据这两个指针就可以随时确定栈顶元素的位置和栈的状态（空或满），因为栈这种特殊的数据结构可以保证后进⼊的数据先出来，所以栈在迷宫找路是可以模拟出⾛过的每⼀步以及遇到障碍时往后退的上⼀步位置（也就是后进⼊的栈顶元素），所以可以创建⼀个栈，⾥⾯的指针类型为定义的结构体类型2.详细设计⾸先根据⽤户输⼊的长和宽m和n⽤new去开辟⼤⼩为m+2（算上围墙）⼤⼩的内存，在m+2的基础上再⽤new开放n+2（算上围墙）⼤⼩的内存，就开辟了⼆维数组空间，返回的值（数组的地址）⽤⼀个⼆重指针去存放：具体代码如下（该函数在function.h）int **initmaze(int &m,int &n)//⽤0或1输⼊代表迷宫，0代表通路{cout << "请输⼊迷宫的长和宽" << endl;cout << "长度：";cin >> m;cout << "宽度：";cin >> n;cout << "请创建迷宫,0代表通路，1代表此路不通" << endl;int **maze = new int *[n + 2];//⽤new,避免缓冲区溢出for (int i = 0; i <= n + 1; i++)//创建迷宫储存空间，为迷宫设置障碍{maze[i] = new int[m+2];//长度加2,为迷宫周围设置障碍}for (int i = 0; i <= n + 1; i++){maze[i][0] = maze[i][m + 1] = 1;//为每⼀⾏的第⼀个和最后⼀个元素初始化为1，为迷宫的障碍}for (int i = 0; i <= m + 1; i++){maze[0][i] = maze[n + 1][i] = 1;//为每⼀列的第⼀个和最后⼀个元素初始化值为1,为迷宫障碍}for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){maze[i][j]=0;}}return maze;}在stack.h这个头⽂件定义栈这种数据结构，定义结构体position⽤来存放迷宫⾥点的坐标，代码如下：struct position{int row;//⾏偏移int col;//列偏移};//定义⼀个结构体，⽤来存放位置坐标typedef position selemtype;typedef struct//定义栈结构为结构体栈,⽤来存放迷宫中某⼀点的横纵坐标{selemtype *top;//栈顶指针selemtype *base;//栈底指针int stacksize;}sqstack;定义initstack函数初始化栈，具体操作⽤new开辟⼀段内存，将这段内存的⾸地址赋值给top和base（两个指向position结构体类型的指针）⽤来表⽰存放路径的栈：bool initstack(sqstack &s)//顺序栈的初始化{s.base = new selemtype[MAXSIZE];//为顺序栈分配空间if (!s.base) return 0;//储存分配失败s.top = s.base;s.stacksize = MAXSIZE;return 1;}定义⼀些函数去对栈进⾏操作该函数将⾛过的点存放到栈⾥⾯，将栈顶指针重新向上移⼀位，指向栈顶元素bool push(sqstack &s, selemtype e)//插⼊元素e为栈顶元素{if (s.top - s.base == s.stacksize) exit(0);//空间已满，分配失败*s.top = e;//将值赋给栈顶指针s.top++;//栈顶指针向上移1位return 1;}该函数删除栈顶元素，即将栈顶指针向下移⼀位（在迷宫⾥表⽰遇到障碍退路）：bool pop(sqstack &s, selemtype &e)//删除栈顶元素{if (empty(s)) return 0;//栈为空，不能删除e = *(s.top-1);//将栈顶指针减⼀，将栈顶元素赋给es.top--;return 1;}该函数取得栈顶元素，及取回top指针指向的元素（在迷宫⾥表⽰退到上⼀位置，因为栈顶元素就是对应上⼀步）该函数判断栈是否为满，根据指针位置判断bool full(sqstack &s)//判断栈是否满了{if (s.top - s.base == 0)return 0;else return 1;}该函数判断栈是否为空，根据指针位置判断bool empty(sqstack &s)//判断栈是否为空{if (s.base == s.top)return 1;else return 0;}该函数输出栈中元素，表⽰输出迷宫从⼊⼝到出⼝的路径void stackprint(sqstack s)//输出栈中元素{selemtype *q;for (q = s.base; q !=s.top; q++){cout << "("<<q->row << "," <<q->col<<")"<< endl;}}以上对栈的操作都放⼊stack.h头⽂件中上述实现了迷宫需要⽤到的⼀些数据类型和数据结构接下来分析如何实现迷宫问题⽐如以下是⼀个迷宫，长和宽为4，旁边代表围墙，⼊⼝为（1,1），⾸先要⽣成障碍，有两个选择，⼿动和⾃动⽣成，其实没区别，只需要把障碍对应的坐标设置为1即可，⾃动就是在指定的长宽内去⽣成随机数，⼀下为⾃动和⼿动的代码实现int **randmaze(int **p, int &m, int &n)//随机产⽣障碍{time_t t=time(0);srand(t);int num, x, y;cout << "请输⼊障碍物的个数"<<endl;cin >> num;cout << "ok,正在为你⽣出障碍物....请稍等" << endl;for (int i = 0; i < num; i++){x = rand() % m;//⽣成的随机数在指定迷宫长度的范围内,不包括出⼝y = rand() % n;//⽣成随机数在指定迷宫宽度的范围内p[x][y] = 1;//设置障碍}return p;}int **inputmaze(int **p, int &m, int &n)//⼿动输⼊障碍{int num, x, y;cout << "请输⼊设置障碍物的个数" << endl;cin >> num;cout << "请输⼊障碍物的位置,⾏和列" << endl;for (int i = 0; i < num; i++){cout << "⾏:";cin >> x;cout << "列:";cin >> y;while ((x<=1 || x >=n) && (y <= 1 || y >=m))//出⼝⼊⼝均不能有障碍{cout << "输⼊不在范围内" << endl;cout << "⾏:";cin >> x;cout << "列:";cin >> y;}p[x][y] = 1;}return p;}设置好障碍后就开始找路，每个点都有四个选择，及向上下左右，那么可以⽤结构体去存放相应的偏移量，⽐如右偏移为⾏为0，列偏移为1position offset[4];//结构体数组，存放位置偏移量offset[0].row = 0; offset[0].col = 1;//右偏移offset[1].row = 1; offset[1].col = 0;//下偏移offset[2].row = 0; offset[2].col = -1;//左偏移offset[3].row = -1; offset[3].col = 0;//上偏移这个顺序是有要求的先向右尝试，然后是下，再左，最后上假设⽣成的障碍为如下所⽰先从⼊⼝（1,1）当前位置向右尝试，不⾏（右为1障碍），于是向下（可以，因为下个位置为0），⾛到（2,1），将（1,1）设为2（表⽰来过，防⽌再次⾛），然后将（1,1）存⼊栈，接着（2,2）⼜有4种尝试，先向右（右（2,2）为0，所以可以⾛）于是将（1,2）设为2表⽰⾛过并存⼊栈中，接着到（2,2），先向右尝试，（2,3）为1，遇到障碍，再向下尝试，还是障碍，接着上和左都不⾏，于是只能后退了，于是将上个位置（1,2）从栈中弹出来，将上个位置变成当前位置，接着因为（1,2）已经向右尝试过了不⾏，于是要从下（结构体下标为1offset[1].row = 1; offset[1].col = 0;//下偏移）开始尝试，向下可以，于是到（1,3），将（1,2）压⼊栈，下⾯都是按照上⾯讲的⼀⼀去尝试，直到⾛到出⼝，接着将栈输出即可，该找路部分实现代码如下bool findpath(int **p,int &m,int &n,sqstack &path)//sqstack为存放路径的结构体栈{initstack(path);position offset[4];//结构体数组，存放位置偏移量offset[0].row = 0; offset[0].col = 1;//右偏移offset[1].row = 1; offset[1].col = 0;//下偏移offset[2].row = 0; offset[2].col = -1;//左偏移offset[3].row = -1; offset[3].col = 0;//上偏移position here;//⽤来存放位置here.row = here.col = 1;p[1][1] = 2;//⼊⼝设为2，防⽌在回来int option = 0;//移动⽅向，根据移动⽅向进⾏不同的偏移int lastoption = 3;while (here.row != n||here.col != m)//没到出⼝{int r, c;while (option <= lastoption)//依次⾛⼏个⽅向{r = here.row + offset[option].row;c = here.col + offset[option].col;if (p[r][c] == 0) break;//如果有通路，则跳出option++;//否则尝试下⼀个⽅向}if (option <= lastoption)//如果找到⽅向{push(path, here);//将⽅向压⼊结构体栈here.row = r;here.col = c;p[r][c] = 2;//将该点改为2，表⽰来过option = 0;//重新设置为0，进⾏下⼀次寻路}else{position next;if (empty(path)){return false;}next = gettop(path);//取栈顶元素，及前⼀点坐标pop(path, next);//将栈顶弹出if (here.row == next.row)//如果当前位置和上⼀位置⾏相等，说明他们在列上移{if (here.col > next.col){option = 1;}else{option = 3;}//option = 2 + next.col - here.col;//下⼀个移动位置}else{if (here.row > next.row){option = 2;}else{return false;}//option = 3 + next.row - here.row;//如果当前位置和上⼀位置列相同,说明当前位置是从⾏上移过来的}here = next;//把栈顶元素（上⼀位置坐标赋给当前位置，表⽰退回来）}}return true;}具体代码在此贴出#ifndef _STACK0_#define_STACK0_#define MAXSIZE 100struct position{int row;//⾏偏移int col;//列偏移};//定义⼀个结构体，⽤来存放位置坐标typedef position selemtype;typedef struct//定义栈结构为结构体栈,⽤来存放迷宫中某⼀点的横纵坐标{selemtype *top;//栈顶指针selemtype *base;//栈底指针int stacksize;}sqstack;bool full(sqstack &s)//判断栈是否满了{if (s.top - s.base == 0)return 0;else return 1;}bool empty(sqstack &s)//判断栈是否为空{if (s.base == s.top)return 1;else return 0;}bool initstack(sqstack &s)//顺序栈的初始化{s.base = new selemtype[MAXSIZE];//为顺序栈分配空间if (!s.base) return 0;//储存分配失败s.top = s.base;s.stacksize = MAXSIZE;return 1;}bool push(sqstack &s, selemtype e)//插⼊元素e为栈顶元素{if (s.top - s.base == s.stacksize) exit(0);//空间已满，分配失败*s.top = e;//将值赋给栈顶指针s.top++;//栈顶指针向上移1位return 1;}bool pop(sqstack &s, selemtype &e)//删除栈顶元素{if (empty(s)) return 0;//栈为空，不能删除e = *(s.top-1);//将栈顶指针减⼀，将栈顶元素赋给es.top--;return 1;}selemtype gettop(sqstack s)//获取栈顶元素的值{if (s.top == s.base) exit(0);//e=*(s.top - 1);//取栈顶元素return *(s.top-1);}void stackprint(sqstack s)//输出栈中元素{selemtype *q;for (q = s.base; q !=s.top; q++){cout << "("<<q->row << "," <<q->col<<")"<< endl;}}#endif;#ifndef _FUNCTION0_#define_FUNCTION0_#include<iomanip>#include<cstdlib>//⽤来⽣成随机数#include<ctime>#include"stack.h"void welcome(){cout << "初始化迷宫......" << endl;}int **initmaze(int &m,int &n)//⽤0或1输⼊代表迷宫，0代表通路{cout << "请输⼊迷宫的长和宽" << endl;cout << "长度：";cin >> m;cout << "宽度：";cin >> n;cout << "请创建迷宫,0代表通路，1代表此路不通" << endl;int **maze = new int *[n + 2];//⽤new,避免缓冲区溢出for (int i = 0; i <= n + 1; i++)//创建迷宫储存空间，为迷宫设置障碍{maze[i] = new int[m+2];//长度加2,为迷宫周围设置障碍}for (int i = 0; i <= n + 1; i++){maze[i][0] = maze[i][m + 1] = 1;//为每⼀⾏的第⼀个和最后⼀个元素初始化为1，为迷宫的障碍}for (int i = 0; i <= m + 1; i++){maze[0][i] = maze[n + 1][i] = 1;//为每⼀列的第⼀个和最后⼀个元素初始化值为1,为迷宫障碍}for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){maze[i][j]=0;}}return maze;}int **randmaze(int **p, int &m, int &n)//随机产⽣障碍{time_t t=time(0);srand(t);int num, x, y;cout << "请输⼊障碍物的个数"<<endl;cin >> num;cout << "ok,正在为你⽣出障碍物....请稍等" << endl;for (int i = 0; i < num; i++){x = rand() % m;//⽣成的随机数在指定迷宫长度的范围内,不包括出⼝y = rand() % n;//⽣成随机数在指定迷宫宽度的范围内p[x][y] = 1;//设置障碍}return p;}int **inputmaze(int **p, int &m, int &n)//⼿动输⼊障碍{int num, x, y;cout << "请输⼊设置障碍物的个数" << endl;cin >> num;cout << "请输⼊障碍物的位置,⾏和列" << endl;for (int i = 0; i < num; i++){cout << "⾏:";cout << "列:";cin >> y;while ((x<=1 || x >=n) && (y <= 1 || y >=m))//出⼝⼊⼝均不能有障碍{cout << "输⼊不在范围内" << endl;cout << "⾏:";cin >> x;cout << "列:";cin >> y;}p[x][y] = 1;}return p;}void printmaze(int **p,int m,int n){for (int i = 0; i <= n + 1; i++){for (int j = 0; j <= m + 1; j++){if (p[i][j] == 1){cout << setw(2) <<"□";}if (p[i][j] == 2){cout << setw(2) << "○";}if (p[i][j] == 0){cout << setw(2) << "";}}cout << endl;}}void delmaze(int **p, int m, int n)//销毁迷宫{for (int i = 0; i <= n + 1; i++){delete[] p[i];}}bool findpath(int **p,int &m,int &n,sqstack &path)//sqstack为存放路径的结构体栈{initstack(path);position offset[4];//结构体数组，存放位置偏移量offset[0].row = 0; offset[0].col = 1;//右偏移offset[1].row = 1; offset[1].col = 0;//下偏移offset[2].row = 0; offset[2].col = -1;//左偏移offset[3].row = -1; offset[3].col = 0;//上偏移position here;//⽤来存放位置here.row = here.col = 1;p[1][1] = 2;//⼊⼝设为2，防⽌在回来int option = 0;//移动⽅向，根据移动⽅向进⾏不同的偏移int lastoption = 3;while (here.row != n||here.col != m)//没到出⼝{int r, c;while (option <= lastoption)//依次⾛⼏个⽅向{r = here.row + offset[option].row;c = here.col + offset[option].col;if (p[r][c] == 0) break;//如果有通路，则跳出option++;//否则尝试下⼀个⽅向}if (option <= lastoption)//如果找到⽅向{push(path, here);//将⽅向压⼊结构体栈here.row = r;here.col = c;p[r][c] = 2;//将该点改为2，表⽰来过option = 0;//重新设置为0，进⾏下⼀次寻路}else{position next;if (empty(path)){return false;}next = gettop(path);//取栈顶元素，及前⼀点坐标pop(path, next);//将栈顶弹出if (here.row == next.row)//如果当前位置和上⼀位置⾏相等，说明他们在列上移{if (here.col > next.col){option = 1;}else{option = 3;}//option = 2 + next.col - here.col;//下⼀个移动位置}else{if (here.row > next.row){option = 2;}else{return false;}//option = 3 + next.row - here.row;//如果当前位置和上⼀位置列相同,说明当前位置是从⾏上移过来的}here = next;//把栈顶元素（上⼀位置坐标赋给当前位置，表⽰退回来）}}return true;}#endif;#include<iostream>using namespace std;#include"function.h"int main(){int m, n,t;int **maze;sqstack path;//⽤来存放路径welcome();maze=initmaze(m,n);//初始化函数printmaze(maze,m,n);//输出初始化的迷宫cout << "选择1⾃动⽣成障碍" << endl;cout << "选择2⼿动创建障碍" << endl;cin >> t;while (t != 1 && t != 2){cout << "输⼊错误，请重输" << endl;cin >> t;}switch (t){case 1:maze = randmaze(maze, m, n); break; case 2:maze = inputmaze(maze, m, n); break; }cout << "迷宫如下"<<endl;printmaze(maze,m,n);cout << "正在寻找路径" << endl;if (findpath(maze, m, n,path)){stackprint(path);}else{cout << "没有找到路径" << endl;}printmaze(maze,m,n);delmaze(maze, m, n);//销毁迷宫，释放内存return 0;}。

数据结构老鼠迷宫VC源程序

数据结构老鼠迷宫VC源程序

＃include〈stdio。

h〉#include〈string.h>#include〈stdlib。

h>#define for if（0）;else for＃define max 300char map[max]［max］；int cross,vertical；//老鼠的横纵坐标int time；typedef struct｛int x，y;int step;｝point；point s；point queue[100*max];int a［max］［max]；int dx［4］=｛0,1，0,-1}；int dy［4]=｛1，0,—1,0｝;int value_place（point tmp, int i，int row, int col){if(tmp。

x+dx［i］〉=0 ＆＆tmp。

x+dx［i]〈row ＆＆tmp。

y+dy［i］〉=0 &＆tmp。

y+dy［i]〈col &&map［tmp.x+dx[i］]［tmp。

y+dy[i］］！='＊’&＆a[tmp.x+dx［i]][tmp.y+dy[i］]==0) return 1;return 0;｝int Bfs（point start, int row, int col)｛int i,front=0,tail=1;point tmp；tmp =start;queue［0］= tmp；queue[0］。

step = 0；while（front ！= tail）｛for(i=0; i〈4；i++）{if（value_place（tmp，i，row，col））｛if（map[tmp.x+dx[i］］[tmp.y+dy[i]]==’C'）return queue[front]。

step+1；queue［tail］.x = tmp.x+dx[i］；queue［tail］.y = tmp。

顺序栈和迷宫求解（C语言）

顺序栈和迷宫求解（C语言）

顺序栈和迷宫求解（C语⾔）顺序栈 根据《数据结构》书中的讲解，对顺序栈的⼀个基本实现。

define.h1// define.h2 #ifndef __MENGQL_DEFINE__3#define __MENGQL_DEFINE__45#define C_LOG_DBG(format, ...)6//printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);7#define C_LOG_ERR(format, ...) printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);8 typedef enum EStatus {ERROR, OK} Status;910#endifSqStack.h1// SqStack.h2 #ifndef __SQ_STACK_H__3#define __SQ_STACK_H__4 #include "define.h"56 typedef struct7 {8int x;9int y;10 }PosType;1112 typedef struct13 {14int ord;15 PosType seat;16int di;17 }SElemType;1819#define STACK_INIT_SIZE 10020 typedef struct21 {22 SElemType* base;23 SElemType* top;24int stacksize;25 }SqStack;2627extern Status InitStack(SqStack *S);28extern Status GetTopStack(SqStack S, SElemType *e);29extern Status PushStack(SqStack *S, SElemType e);30extern Status PopStack(SqStack *S, SElemType *e);31extern Status StackEmpty(SqStack *S);32extern Status DestoryStack(SqStack *S);33#endifSqStack.c1// SqStack.c2 #include "define.h"3 #include "SqStack.h"4 #include <stdlib.h>5 #include <stdio.h>6 Status InitStack(SqStack *S)7 {8 S->stacksize = STACK_INIT_SIZE;9 S->base = (SElemType *)malloc(S->stacksize * sizeof(SElemType));10if(S->base == NULL)11 {12 C_LOG_ERR("%s\n","MALLOC OVERFLOW");13return ERROR;14 }15 S->top = S->base;1617return OK;18 }19 Status GetTopStack(SqStack S, SElemType *e)20 {21if(S.top == S.base)22 {23 C_LOG_ERR("%s\n","STACK IS EMPTY");24return ERROR;25 }26 *e = *(S.top-1);27return OK;28 }29 Status PushStack(SqStack *S, SElemType e)30 {31if(S->top - S->base >= S->stacksize)32 {33 S->base = (SElemType *)realloc(S->base, (S->stacksize * 2) * sizeof(SElemType)); 34if(S->base == NULL)35 {36 C_LOG_ERR("%s\n","REMALLOC OVERFLOW");37return ERROR;38 }39 S->stacksize *= 2;40 }41 *(S->top++) = e;42return OK;43 }44 Status PopStack(SqStack *S, SElemType *e)45 {46if(S->top == S->base)47 {48 C_LOG_ERR("%s\n","STACK IS EMPTY");49return ERROR;50 }51 *e = *(--S->top);52return OK;53 }54 Status StackEmpty(SqStack *S)55 {56if(S->top == S->base)57 {58return OK;59 }60return ERROR;61 }62 Status DestoryStack(SqStack *S)63 {64 S->stacksize = 0;65 free(S->base);66 S->top = S->base = NULL;67return OK;68 }迷宫求解 顺序栈实现的迷宫求解是深度优先搜索，得出的路径是⾮最短路径。

数据结构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。

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

#include<iostream>
using namespace std;
#define M 5
#define N 5//外部定义矩阵规模
int m,n,k,l,min,lenth=0;
int migong[M][N];
int go[M][N]={0};//记录不能被访问点的下标，标记最终路径
bool howtogo(int x,int y,int m,int n,int k,int l,int lenth){//x,y当前点；m,n边界最大值；k,l目标终点；
bool hg,bg;
if(x<0||y<0||x>m||y>n)//边界外
return false;
if(go[x][y]==0 ){
go[x][y]=1;
lenth++;
if(lenth>=min) //检索次数大于所有点个数，一定错误，防止环路死循环
return false;
}
else
return false;
if(x==k && y==l){
if(lenth<min){//到达目标位置，并判断选取最短路径
min=lenth;
go[x][y]=min;//用路径长标记路径
return true;
}
else return false;
}
hg=howtogo(x+1,y,m,n,k,l,lenth);//下右上左
if(hg==true)
{go[x][y]=min;bg=hg;}//标记路径
hg=howtogo(x,y+1,m,n,k,l,lenth);
if(hg==true)
{go[x][y]=min;bg=hg;}
hg=howtogo(x-1,y,m,n,k,l,lenth);
if(hg==true)
{go[x][y]=min;bg=hg;}
hg=howtogo(x,y-1,m,n,k,l,lenth);
if(hg==true)
{go[x][y]=min;bg=hg;}
return bg;
}
void main(){
m=M;
n=N;//边界宏定义
cout<<"迷宫大小为"<<M<<"行,"<<N<<"列\n请输入出口的视坐标，行、列";//终点cin>>l;
cin>>k;
min=m*n;//辅助选取最短路径
cout<<"按先行后列的顺序输入各点值:";
for(int i=0;i<m;i++)//输入迷宫
for(int j=0;j<n;j++)
cin>>migong[i][j];
cout<<"迷宫为"<<endl;//输出迷宫图案
for(int i1=0;i1<m;i1++)
{for(int j1=0;j1<n;j1++){
go[i1][j1]=migong[i1][j1];
cout<<migong[i1][j1]<<" ";
}
cout<<endl;
}//返回值代表是否存在路径
if(howtogo(0,0,m-1,n-1,k-1,l-1,lenth)){//(0,0)起始，(m-1,n-1)边界，(k-1,l-1)终止cout<<"正确路径为数字"<<min<<"所在点\n";
for(int i=0;i<m;i++){
for (int j=0;j<n;j++)
cout<<go[i][j]<<" ";
cout<<endl;
}
}
else
cout<<"不可到达目标出口"<<endl;
system("pause");
}。

相关文档
最新文档