栈方法 做迷宫

最新推荐文章于 2022-12-13 01:55:35 发布
最新推荐文章于 2022-12-13 01:55:35 发布
阅读量1.2k 收藏 14
点赞数 5
分类专栏： C语言 文章标签： 迷宫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liaring/article/details/102790396
版权

原理：通过栈的原理 先进后出 后进先出
通过对迷宫的不断查找
找到最好的
//图的搜索策略解决迷宫问题
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
#define OVERFLOW 0
#define ERROR 0
#define OK 1

#define M 10 //迷宫的列数
#define N 10 //迷宫的行数

typedef struct{
int pi;//父节点的行号
int pj;//父节点的列号
int i;//当前节点的行号
int j;//当前节点的列号
}SElemType; //定义栈元素类型

typedef struct{
int i;//当前节点的行号
int j;//当前节点的列号
}Node; //定义节点元素类型

typedef struct
{
SElemType *base; //在栈构造之前和销毁之后，base的值为NULL
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

typedef int Status;

static int MM[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//迷宫

static int F[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//足迹;

Status InitStack(SqStack &s)
{
//构造一个空栈S
s.base=(SElemType )malloc(STACK_INIT_SIZEsizeof(SElemType));
if(!s.base) //存储分配失败
exit(OVERFLOW);
s.top=s.base;
s.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack

Status GetTop(SqStack s,SElemType &e)
{
//若栈不空，则用e返回s的栈顶元素，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*(s.top-1);
return OK;
}//GetTop

Status 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;
}//Push

Status Pop(SqStack &s,SElemType &e)
{
//若栈不空，则删除s的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*–s.top;
return OK;
}//Pop

Status empty(SqStack s)
{
if(s.top-s.base==0)//判断是否为空，此栈为空两指针大小相等，否则不为空
return 1;
else
return 0;
}//empty

//取下一个节点
Status GetNextnode(Node e1,int n,Node &e2){
//参数e1表示当前节点，n表示方向n=1,2,…,8，考虑了8个方向
//若下一个节点存在，则函数返回OK，下一个节点的值存放在e2中；
//方向的约定是正下方为1，右下方2，正右方为3，右上方4，正上方为5，左上方6，正左方为7，左下方8
switch(n){
case 1://正下方
{
e2.i=e1.i+1;
e2.j=e1.j;
break;
}
case 2://右下方
{
e2.i=e1.i+1;
e2.j=e1.j+1;
break;
}
case 3://正右方
{
e2.i=e1.i;
e2.j=e1.j+1;
break;
}
case 4://右上方
{
e2.i=e1.i-1;
e2.j=e1.j+1;
break;
}
case 5://正上方
{
e2.i=e1.i-1;
e2.j=e1.j;
break;
}
case 6://左上方
{
e2.i=e1.i-1;
e2.j=e1.j-1;
break;
}
case 7://正左方
{
e2.i=e1.i;
e2.j=e1.j-1;
break;
}
case 8://左下方
{
e2.i=e1.i+1;
e2.j=e1.j-1;
break;
}
default: return 0;
}
printf("%d,%d,n=%d\n",e2.i,e2.j,n);
return 1;
}

int compassable(Node e)
{
printf("%d,%d\n",e.i,e.j);
return F[e.i][e.j];
}

void SearchPath()
{
SqStack s;
Node e1,e2,end;
SElemType se,se1,p[100];
int i=0,di,j;

InitStack(s);//初始化栈

//指定入口
e1.i=1;e1.j=1;
//指定出口
end.i=8;end.j=8;
//构造栈元素
se.pi=0;se.pj=0;se.i=e1.i;se.j=e1.j;
Push(s,se);
printf("****************\n");
while(!empty(s)){
Pop(s,se);
//将se插入的closed表中
p[i].i=se.i;
p[i].j=se.j;
p[i].pi=se.pi;
p[i].pj=se.pj;
i++;
printf("++++++++++++++%d++++++\n",i);

//判断是否达到终点,如果到达终点则跳出while循环.
if(se.i==end.i&&se.j==end.j) {printf("\nThe path hava found!\n");break;}
//没有到达终点则将se的下一代可行的节点入栈

e1.i=se.i;e1.j=se.j;
for(di=1;di<=8;di++)//考虑八个方向
{
   GetNextnode(e1,di,e2);
   printf("%d,%d,di=%d\n",e1.i,e1.j,di);
   if(compassable(e2))
   {
       //构造栈元素
       se1.i=e2.i;
       se1.j=e2.j;
       se1.pj=se.j;
       se1.pi=se.i;
       //下一代可通的节点入栈
       Push(s,se1);
       //留下足迹
       F[e2.i][e2.j]=0;
       printf("_____________________\n");
   }//endif
}//endfor

}//endwhile
for(j=0;j<i;j++)
printf(“i=%d,j=%d,pi=%d,pj=%d\n”,p[j].i,p[j].j,p[j].pi,p[j].pj);
}

main()
{

SearchPath();
return 1;
}

//图的搜索策略解决迷宫问题
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
#define OVERFLOW 0
#define ERROR 0
#define OK 1

#define M 10 //迷宫的列数
#define N 10 //迷宫的行数

typedef struct{
int pi;//父节点的行号
int pj;//父节点的列号
int i;//当前节点的行号
int j;//当前节点的列号
}SElemType; //定义栈元素类型

typedef struct{
int i;//当前节点的行号
int j;//当前节点的列号
}Node; //定义节点元素类型

typedef struct
{
SElemType *base; //在栈构造之前和销毁之后，base的值为NULL
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

typedef int Status;

static int MM[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//迷宫

static int F[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//足迹;

Status InitStack(SqStack &s)
{
//构造一个空栈S
s.base=(SElemType )malloc(STACK_INIT_SIZEsizeof(SElemType));
if(!s.base) //存储分配失败
exit(OVERFLOW);
s.top=s.base;
s.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack

Status GetTop(SqStack s,SElemType &e)
{
//若栈不空，则用e返回s的栈顶元素，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*(s.top-1);
return OK;
}//GetTop

Status 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;
}//Push

Status Pop(SqStack &s,SElemType &e)
{
//若栈不空，则删除s的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*–s.top;
return OK;
}//Pop

Status empty(SqStack s)
{
if(s.top-s.base==0)//判断是否为空，此栈为空两指针大小相等，否则不为空
return 1;
else
return 0;
}//empty

//取下一个节点
Status GetNextnode(Node e1,int n,Node &e2){
//参数e1表示当前节点，n表示方向n=1,2,…,8，考虑了8个方向
//若下一个节点存在，则函数返回OK，下一个节点的值存放在e2中；
//方向的约定是正下方为1，右下方2，正右方为3，右上方4，正上方为5，左上方6，正左方为7，左下方8
switch(n){
case 1://正下方
{
e2.i=e1.i+1;
e2.j=e1.j;
break;
}
case 2://右下方
{
e2.i=e1.i+1;
e2.j=e1.j+1;
break;
}
case 3://正右方
{
e2.i=e1.i;
e2.j=e1.j+1;
break;
}
case 4://右上方
{
e2.i=e1.i-1;
e2.j=e1.j+1;
break;
}
case 5://正上方
{
e2.i=e1.i-1;
e2.j=e1.j;
break;
}
case 6://左上方
{
e2.i=e1.i-1;
e2.j=e1.j-1;
break;
}
case 7://正左方
{
e2.i=e1.i;
e2.j=e1.j-1;
break;
}
case 8://左下方
{
e2.i=e1.i+1;
e2.j=e1.j-1;
break;
}
default: return 0;
}
printf("%d,%d,n=%d\n",e2.i,e2.j,n);
return 1;
}

int compassable(Node e)
{
printf("%d,%d\n",e.i,e.j);
return F[e.i][e.j];
}

void SearchPath()
{
SqStack s;
Node e1,e2,end;
SElemType se,se1,p[100];
int i=0,di,j;

InitStack(s);//初始化栈

//指定入口
e1.i=1;e1.j=1;
//指定出口
end.i=8;end.j=8;
//构造栈元素
se.pi=0;se.pj=0;se.i=e1.i;se.j=e1.j;
Push(s,se);
printf("****************\n");
while(!empty(s)){
Pop(s,se);
//将se插入的closed表中
p[i].i=se.i;
p[i].j=se.j;
p[i].pi=se.pi;
p[i].pj=se.pj;
i++;
printf("++++++++++++++%d++++++\n",i);

//判断是否达到终点,如果到达终点则跳出while循环.
if(se.i==end.i&&se.j==end.j) {printf("\nThe path hava found!\n");break;}
//没有到达终点则将se的下一代可行的节点入栈

e1.i=se.i;e1.j=se.j;
for(di=1;di<=8;di++)//考虑八个方向
{
   GetNextnode(e1,di,e2);
   printf("%d,%d,di=%d\n",e1.i,e1.j,di);
   if(compassable(e2))
   {
       //构造栈元素
       se1.i=e2.i;
       se1.j=e2.j;
       se1.pj=se.j;
       se1.pi=se.i;
       //下一代可通的节点入栈
       Push(s,se1);
       //留下足迹
       F[e2.i][e2.j]=0;
       printf("_____________________\n");
   }//endif
}//endfor

}//endwhile
for(j=0;j<i;j++)
printf(“i=%d,j=%d,pi=%d,pj=%d\n”,p[j].i,p[j].j,p[j].pi,p[j].pj);
}

main()
{

SearchPath();
return 1;
}

//图的搜索策略解决迷宫问题
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
#define OVERFLOW 0
#define ERROR 0
#define OK 1

#define M 10 //迷宫的列数
#define N 10 //迷宫的行数

typedef struct{
int pi;//父节点的行号
int pj;//父节点的列号
int i;//当前节点的行号
int j;//当前节点的列号
}SElemType; //定义栈元素类型

typedef struct{
int i;//当前节点的行号
int j;//当前节点的列号
}Node; //定义节点元素类型

typedef struct
{
SElemType *base; //在栈构造之前和销毁之后，base的值为NULL
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

typedef int Status;

static int MM[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//迷宫

static int F[10][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,0,0,0,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,0,0,1,0,1,1,1,0},
{0,1,0,1,1,1,1,0,1,0},
{0,1,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0}};//足迹;

Status InitStack(SqStack &s)
{
//构造一个空栈S
s.base=(SElemType )malloc(STACK_INIT_SIZEsizeof(SElemType));
if(!s.base) //存储分配失败
exit(OVERFLOW);
s.top=s.base;
s.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack

Status GetTop(SqStack s,SElemType &e)
{
//若栈不空，则用e返回s的栈顶元素，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*(s.top-1);
return OK;
}//GetTop

Status 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;
}//Push

Status Pop(SqStack &s,SElemType &e)
{
//若栈不空，则删除s的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(s.top==s.base) return ERROR;
e=*–s.top;
return OK;
}//Pop

Status empty(SqStack s)
{
if(s.top-s.base==0)//判断是否为空，此栈为空两指针大小相等，否则不为空
return 1;
else
return 0;
}//empty

//取下一个节点
Status GetNextnode(Node e1,int n,Node &e2){
//参数e1表示当前节点，n表示方向n=1,2,…,8，考虑了8个方向
//若下一个节点存在，则函数返回OK，下一个节点的值存放在e2中；
//方向的约定是正下方为1，右下方2，正右方为3，右上方4，正上方为5，左上方6，正左方为7，左下方8
switch(n){
case 1://正下方
{
e2.i=e1.i+1;
e2.j=e1.j;
break;
}
case 2://右下方
{
e2.i=e1.i+1;
e2.j=e1.j+1;
break;
}
case 3://正右方
{
e2.i=e1.i;
e2.j=e1.j+1;
break;
}
case 4://右上方
{
e2.i=e1.i-1;
e2.j=e1.j+1;
break;
}
case 5://正上方
{
e2.i=e1.i-1;
e2.j=e1.j;
break;
}
case 6://左上方
{
e2.i=e1.i-1;
e2.j=e1.j-1;
break;
}
case 7://正左方
{
e2.i=e1.i;
e2.j=e1.j-1;
break;
}
case 8://左下方
{
e2.i=e1.i+1;
e2.j=e1.j-1;
break;
}
default: return 0;
}
printf("%d,%d,n=%d\n",e2.i,e2.j,n);
return 1;
}

int compassable(Node e)
{
printf("%d,%d\n",e.i,e.j);
return F[e.i][e.j];
}

void SearchPath()
{
SqStack s;
Node e1,e2,end;
SElemType se,se1,p[100];
int i=0,di,j;

InitStack(s);//初始化栈

//指定入口
e1.i=1;e1.j=1;
//指定出口
end.i=8;end.j=8;
//构造栈元素
se.pi=0;se.pj=0;se.i=e1.i;se.j=e1.j;
Push(s,se);
printf("****************\n");
while(!empty(s)){
Pop(s,se);
//将se插入的closed表中
p[i].i=se.i;
p[i].j=se.j;
p[i].pi=se.pi;
p[i].pj=se.pj;
i++;
printf("++++++++++++++%d++++++\n",i);

//判断是否达到终点,如果到达终点则跳出while循环.
if(se.i==end.i&&se.j==end.j) {printf("\nThe path hava found!\n");break;}
//没有到达终点则将se的下一代可行的节点入栈

e1.i=se.i;e1.j=se.j;
for(di=1;di<=8;di++)//考虑八个方向
{
   GetNextnode(e1,di,e2);
   printf("%d,%d,di=%d\n",e1.i,e1.j,di);
   if(compassable(e2))
   {
       //构造栈元素
       se1.i=e2.i;
       se1.j=e2.j;
       se1.pj=se.j;
       se1.pi=se.i;
       //下一代可通的节点入栈
       Push(s,se1);
       //留下足迹
       F[e2.i][e2.j]=0;
       printf("_____________________\n");
   }//endif
}//endfor

}//endwhile
for(j=0;j<i;j++)
printf(“i=%d,j=%d,pi=%d,pj=%d\n”,p[j].i,p[j].j,p[j].pi,p[j].pj);
}

main()
{

SearchPath();
return 1;
}

Liaring
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用栈实现迷宫
hei我在这
04-06 1036
迷宫是个益智的小游戏，但是就算是个小游戏也会有外挂吧，那么就来写一个小小的迷宫来玩玩吧（虽然是程序自己走的。。）但是这个不重要，重要的是，我不用烧脑玩迷宫啊~//面向对象实现迷宫 #include&lt;stack&gt; struct Pos { int _row; //行 int _col; //列 }; template&lt;size_t N&gt; class Maze { ...
用栈实现迷宫求解Maze
yulijuanxmu的博客
07-16 1581
今天我参考严蔚敏的《数据结构》第3章 栈和队列的3.2.4上的问题描述、解决思路和伪代码把迷宫求解的问题自己实现了一遍，感觉超开心的哇~~嘻嘻，贴出来，以供以后翻阅。 解决过程中的几点思考： 1.对于position NextPos(position cur, int dir)函数，它的目的不是提供一个可行的下一个位置，而是提供一个下一个要考虑的位置，至于可不可行，暂时不用考虑，可不可行的判断...
【Day6·超详细】数据结构 之 栈的应用 迷宫问题详解（包含详细举例）
亿维数组's博客
07-09 4269
这篇文章将会非常详细介绍如何用栈去简单地找一个迷宫的路径目录导读迷宫准备工作超详细举例完整代码 这是一个迷宫，如果想让计算机去找一条从起点到终点的路径，通常利用“穷举求解”，先到达A，往下走到B，再到D，再到H，发现没有路了，回溯到D，再到I，没有路了回溯到D，再到J，没有路了，回溯到D再回溯到B，再到K......，最终回溯到A，再经过几次“撞墙”，终于到达终点。通过这个简单的例子，可以看出，完成迷宫核心的思想是“回溯”，那么我们如何去保存之前走过的路径呢？由于回溯的起点是回溯前路径的终点，所以最好的办法
【数据结构Note3】- 栈 应用栈求解迷宫路径
weixin_63267854的博客
12-13 2228
求解迷宫路径整体思路就是穷举所有路径。从点出发，按某一方向探索，沿途在经过的位置设下标记。若能走通即某处可以到达。若该点所有方向均没有通路，则原返回，直到有路可走。如此循环直到到达终点，或无路可走返回起点。求解过程会用一个栈path存储迷宫路径上的所有有效坐标。
利用栈写的简单的迷宫代码
11-14
自己写的简单迷宫代码 利用栈 找到一个从入口到出口的路径 解决了回路问题 能动态显示寻径过程。开发环境 vc6.0
使用栈解决迷宫路径问题
03-16
迷宫求解是数据结构中一个经典的程序设计题，一般情况下采用的式穷举求解的方法，即从迷宫的入口出发，沿着某一方向前进，若能走通则继续前进，若不通需原路退回后改变方向继续前进，直到找到出口为止，为了保证在...
C++利用循环和栈实现走迷宫
08-27
C++利用循环和栈实现走迷宫 本文主要介绍了如何使用 C++ 语言通过循环和栈实现迷宫的解决方案。该方案通过读取文件中的地图信息，使用栈来存储迷宫的路径，并通过循环来遍历迷宫以找到出口。 知识点一：文件读取和...
数据结构 迷宫问题 C++ 栈方法
01-30
数据结构课程设计之C++编写的迷宫问题路径求解程序，使用的是栈方法，即将路径上每一步存在栈中，迷宫文件格式见程序提示，压缩包内已经给出了三个测试用的迷宫地图可用来测试，支持分步显示查找路径过程功能，当给...
C++ 自定义栈实现迷宫求解
08-30
今天我们将介绍使用栈来实现迷宫求解的方法。 三、迷宫表示 在程序中，我们需要表示迷宫。我们可以使用数组来实现迷宫的表示。例如，以下是一个迷宫的表示： ``` 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0...
用栈结构实现迷宫求解问题
03-02
数据结构试验实验一题目3——利用栈结构实现迷宫求解问题。
迷宫寻径 栈实现
10-11
数据结构课程设计 用栈实现寻径 显示路径
C++用堆栈储存迷宫，并寻找路径
12-21
用堆栈储存迷宫，并寻找路径，运行结果以图示呈现，注释详细
基于栈的C语言迷宫问题与实现
07-07
基于栈的C语言迷宫问题与实现,非常好的源代码，供大家借鉴
利用栈求一条迷宫路径（不一定是最优路径）
qq_37705378的博客
05-07 827
#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#define MazeRow 10//迷宫的行数 #define MazeCol 10//迷宫的列数 static char Maze[MazeRow][MazeCol] = {      {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},      ...
运用栈求解迷宫问题C/C++
热门推荐
g15827636417的博客
10-07 2万+
用栈解决基本的迷宫问题C/C++ 1、问题描述：设置迷宫为m*n的二维数组，起点坐标为（1，1），中点坐标为（m，n），0为通路，1为死路，为防止数组越界将四周设置边界1，即数组变为（m+2）*（n+2）数组，迷宫如下....      迷宫 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 1 1
《数据结构》严蔚敏 用栈实现迷宫求解问题
Yannie's Blog
01-06 6201
转载：https://blog.csdn.net/Vit_rose/article/details/52781116 膜大佬～ 其实自己就是懒，太懒了，不想动手写，有畏难情绪，这个毛病得改鸭 代码如下： #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;string.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #define TRUE 1 #defi...
迷宫问题（运用栈解决）
m0_49938352的博客
07-09 4136
求迷宫中从出口到入口的所有路径，在过程中需要用到栈来存储数据结构； 下标起始值是0，从（1，1）开始走，终点是（3，4），问怎样走才能走到终点？（图画的有问题） 先从数据结构入手，需要的数据结构有栈，还有图中的点。 点的数据定义： typedef struct { int x; //行 int y; //列 int next; //下一个可走元素 }point; 栈的数据定义： typedef struct { point *base; ...
【数据结构】栈 实现迷宫算法
man_zuo的博客
09-06 4848
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include&lt;iostream&gt; using namespace std; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TURE 1 #define FA...
数据结构::迷宫（二）--栈的一个应用（求迷宫最短路径）
海绵宝宝的欧尼~ 的博客
12-06 7832
上篇文章我们知道求解迷宫通路的方法，但是一个迷宫有时是不止一条出路，在这些出路中，我们如何找到最短的那一条，这就是我今天要说的迷宫最短路径问题。 （此处使用的图）： 【先来分析有什么解决方案：】 1、方法一：我们如果采用上章中递归的方式，将所走的路用2标记起来，此时如果找到一条路后，要进行回溯递归，但是到可以走的环中就出现问题了，说的有点迷糊是吧，我把图抛出来。 在这张图中
c语言用栈的方法求迷宫路径
最新发布
05-28
求解迷宫路径可以使用深度优先搜索算法，而栈可以作为深度优先搜索算法的辅助数据结构。具体实现步骤如下： 1. 定义一个栈结构体，包含栈顶指针和栈中元素数组。 2. 定义一个结构体表示迷宫的位置，包含行列坐标和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值