栈实现迷宫

1.解决存储问题

实现迷宫的存储。用一个二维矩阵存储

如下列迷宫:

0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,
 1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,
 0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,
 1,1,0,1,1,1,1,1,0,1,1,0,1,1,0,
 1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,
 0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,
 0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,
 0,0,1,1,0,1,1,0,1,1,1,1,1,0,1,
 1,1,0,0,0,1,1,0,1,1,0,0,0,0,0,
 0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,
 0,1,0,0,1,1,1,1,1,0,1,1,1,1,0,

2.解决移动问题

考虑移动:

有8个方向:

  方位  方向代码(dir)    行移动 (move[dir].vert)   列移动(move[dir].horiz)

  N    0              -1          0

  NE    1              -1          1

  E    2                0            1

  SE    3                1          1

  S    4                1          0

  SW   5                1          -1

  W    6                 0          -1

  NW    7                -1          -1

数据结构表示:

typedef struct{

  short int vert;

  short int horiz;

} offsets;

offsets    move[8];

若当前位置是maze[row][col]

那么下一个位置是maze[next_row][next_col];

next_row=row+move[dir].vert;

next_col=col+move[dir].horiz;

3.解决边界问题

并不是每个移动都有8个位置如边和角的位置,所以为啦避免边界检查,所以再加上一圈边界

若是m*n个元素    则需要(m+2)*(n+2)个存储空间

如下图:

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,     
 1,0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,
 1,1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,1,
 1,0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,
 1,1,1,0,1,1,1,1,1,0,1,1,0,1,1,0,1,
 1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,
 1,0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,
 1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,
 1,0,0,1,1,0,1,1,0,1,1,1,1,1,0,1,1,
 1,1,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,
 1,0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,1,
 1,0,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1

4.这里所用的栈即是上一篇写的基础栈。

代码如下:

  1  #include<stdio.h>
  2  #define MAX_STACK_SIZE 100    //栈的最大元素数
  3
  4
  5  int EXIT_ROW=11,EXIT_COL=15,TRUE=1,FALSE=0,top;
  6  //出口的行列,top栈顶
  7  short int maze[13][17]={        //[m+2][p+2] ;        //15*11迷宫  1,1开始,15,11结束
  8  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  9  1,0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,
 10  1,1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,1,
 11  1,0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,
 12  1,1,1,0,1,1,1,1,1,0,1,1,0,1,1,0,1,
 13  1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,
 14  1,0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,
 15  1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,
 16  1,0,0,1,1,0,1,1,0,1,1,1,1,1,0,1,1,
 17  1,1,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,
 18  1,0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,1,
 19  1,0,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,
 20  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
 21  };
 22  short int mark[13][17]={                //[m+2][p+2] ;        //走过的路程记录
 23  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 24  1,0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,
 25  1,1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,1,
 26  1,0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,
 27  1,1,1,0,1,1,1,1,1,0,1,1,0,1,1,0,1,
 28  1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,
 29  1,0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,
 30  1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,
 31  1,0,0,1,1,0,1,1,0,1,1,1,1,1,0,1,1,
 32  1,1,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,
 33  1,0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,1,
 34  1,0,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,
 35  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
 36  };
 37
 38  typedef struct{
 39      short int vert;
 40      short int horiz;
 41  } offsets;
 42  offsets move[8]={//    dir  vert  horiz    可以移动的位置8个方向
 43  -1,0,                //  0                      上
 44  -1,1,                //  1                    右上
 45  0,1,                //  2                    右
 46  1,1,                //  3                    右下
 47  1,0,                //  4                    下
 48  1,-1,                //  5                    左下
 49  0,-1,                //  6                    左
 50  -1,-1                //  7                    左上
 51  };
 52
 53  typedef struct{        //定义栈的基础元素
 54      short int row;
 55      short int col;
 56      short int dir;
 57  }element;
 58  element stack[MAX_STACK_SIZE];
 59
 60 bool IsFull(int *top );
 61 void  Add(int *top,element item);
 62 bool IsEmpty(int *top );
 63 element Delete(int *top);
 64
 65
 66  void path(void)
 67  {
 68      int i,row,col,next_row,next_col,dir,found=FALSE;
 69      element position;
 70
 71     mark[1][1]=1;        //初始位置 记录已经走过
 72     top=0;                 //栈顶为0
 73     stack[0].row=1;        //给栈顶赋值
 74     stack[0].col=1;
 75     stack[0].dir=1;
 76
 77     while( top > -1 && !found) {
 78         //当栈里元素不空且没有找到路径时做循环
 79         position = Delete(&top);    //找不到出口时回到上一个位置
 80         row = position.row;
 81         col = position.col;
 82         dir = position.dir;
 83
 84         while( dir < 8 && !found ){        //每一个方向
 85         //主要用于找到出口
 86             next_row=row+move[dir].vert;    //每一个方向的下一步
 87             next_col=col+move[dir].horiz;
 88             if(next_row ==EXIT_ROW &&next_col ==EXIT_COL)    //若发现到出口结束
 89             {
 90                     found=TRUE;
 91             }
 92             else if(!maze[next_row][next_col] && !mark[next_row][next_col]){
 93             //若原矩阵和记录矩阵都是 0(即未走过且不是墙壁)
 94                 mark[next_row][next_col]=1;    //记录这个地方已经走过 (封锁避免重复走)
 95
 96                 position.row=row;        //当前位置换方向
 97                 position.col=col;
 98                 position.dir=++dir;
 99                 Add(&top,position);        //入栈 添加回溯点
100                 row=next_row;            //下一个位置 重新从上部开始比较
101                 col=next_col;
102                 dir=0;
103             }
104             else ++dir;
105         }
106     }
107
108     if(found){
109         printf("the path is:\n");
110         printf("row  col\n");
111
112         for(i=0;i<=top;i++){
113             printf("%2d%5d\n",stack[i].row,stack[i].col);
114         }
115         printf("%2d%5d\n",row,col);             //下一个元素
116         printf("%2d%5d\n",EXIT_ROW,EXIT_COL); //出口
117     }
118     else
119         printf("the maze does not have a path\n");
120
121  }
122  int main()
123  {
124      path();
125      int i,j;
126  /*    for(i=0;i<13;i++)            用于查看记录矩阵
127         {
128             for(j=0;j<17;j++)
129                 printf("%d",mark[i][j]);
130             printf("\n");
131         }*/
132
133      return 0;
134  }
135
136
137  bool IsFull(int * top )//1为满0为不满
138 {
139     if(*top >=MAX_STACK_SIZE-1){
140         return 1;
141     }
142     else{
143         return 0;
144     }
145 }
146
147 bool IsEmpty(int *top)//1为空  0为不空
148 {
149     if(*top == -1){
150         return 1;
151     }
152     else{
153         return 0;
154     }
155 }
156 void  Add(int *top,element item)
157 {
158     if(*top >=MAX_STACK_SIZE-1){
159         printf("栈满");
160         return ;
161     }
162     else
163         stack[++(*top)]=item;
164 }
165 element Delete(int *top)
166 {
167     if(*top == -1){
168         printf("栈空");
169     }
170     return stack[(*top)--];
171 }

结果:

the path is:
row  col
 1    1
 2    2
 1    3
 1    4
 1    5
 2    4
 3    5
 3    4
 4    3
 5    3
 6    2
 7    1
 8    2
 9    3
 9    4
 8    5
 7    6
 7    7
 8    8
 9    8
10    9
10   10
 9   11
 9   12
 9   13
 8   14
 9   15
10   15
11   15

走过路径为9数字的;
11111111111111111
19199911999111111
11909119111991111
10119999111199111
11191111101191101
11191001011111111
19911011101001011
19111199111111111
10911911911111911
11199011911999091
10011111099111191
10100111110111101
11111111111111111

真实路径;
11111111111111111
19199911111111111
11909111111111111
10119911111111111
11191111101111101
11191001011111111
11911011101001011
19111199111111111
10911911911111911
11199011911999091
10011111099111111
10100111110111101
11111111111111111
由于最后2步没有入栈所以需要自己输出一下
时间: 2024-10-08 07:12:25

栈实现迷宫的相关文章

利用数据结构栈求解迷宫问题

本段程序主要利用数据结构栈的先进后出特点,实现回溯求解迷宫路径问题. #include<iostream> #include<stack> using namespace std; //坐标类 struct Point { int x; int y; }; //地图类 template<int A> struct Map { int (*p)[A]; int row;//行数 int col;//列数 }; //start起始点, end终止点 template<

利用栈求解迷宫问题

利用栈求解迷宫问题 源代码: #include<stdio.h> #include<stdlib.h> #define M 8 #define N 8 #define MaxSize M*N typedef struct { int i;//当前方块的行号 int j;//当前方块的列号 int di; //di是下一个可走的相邻方块的方位号 }Box; typedef struct { Box data[MaxSize]; int top;      //栈顶指针 }StType

数据结构应用:利用栈破解迷宫游戏

最近刚开始学数据结构,发现数据结构真是个神奇的东西哈,很多现实中的问题都可以用不同的数据结 构来解决,比如利用和栈中缀表达式编写一个计算机程序,利用栈破解迷宫游戏,今天我就来跟大家分 享一下如何利用栈来破解迷宫游戏. 学过数据结构的人都知道,栈的特点是:后进先出(First In Last Out);也就是说只能在栈的尾部进 行压栈和出栈,而且出栈的时候只能从最后一个数据开始.如下图: 而我们在破解迷宫游戏的时候采用的方法是"回溯",也就是在寻找通路的时候,每找到一个通路,就将这个数据

利用栈实现迷宫求解

利用栈实现迷宫求解 前言:众所周知,栈是(First in last out)先进后出的数据结构,利用这个属性可以实现类似与回溯的方式,比如当前数据满足条件,则入栈,否则出栈返回上一级,依次循环. 在本题中,将每个迷宫路径上的点封装成上下左右四个方向数节点,先入栈迷宫入口节点,如果上下左右没被使用,则将其上下左右的点入栈,否则出栈.如果最终达到迷宫终点则成功,否则失败. 如下是每个节点的数据结构 1 typedef struct{ 2 int top; 3 int bottom; 4 int l

栈实现迷宫求解(c++版)

相信大家都应该听过栈吧,一直想利用栈来实现一个算法,最近有点空,就利用栈的先进后出的特性来完成迷宫求的问题,下面将详细介绍栈的实现和迷宫求解的过程,可以很好的学习栈的使用. 栈有两种实现方法,一种是顺序,即数组形式,一种是线性,即链表形式,个人还是比较喜欢链表形式实现栈的基本功能. 首先弄一个简单的迷宫,如图: 我们很容易看出这个迷宫解的路径,那怎么让计算机帮我们求解出来呢. 首先我们要对迷宫数据化,很容易想到二维数组来表示,0表示通路,1表示障碍,即表示为: int map[4][4]={ {

用栈实现迷宫游戏寻路

在我们学习数据结构的时候都曾经见过迷宫游戏,迷宫游戏的实现其实并不难,但是,我们在实现每一个算法的时候都应该想一想这个问题的每一个解.最近,博主已经开始重温数据结构啦,记得我们以前学习这里的时候,老师会用队列来实现迷宫最优解的寻找,氮素呢,博主就是这么可爱,博主就是想试试用栈来找一下. 在实现之前让我们先来复习一下栈的特点:first in last out 对于栈这种数据结构我们只能在栈顶对其操作,根据实际情况可将其实现成链式或者顺序结构.但是一般情况下我们都会实现成顺序结构,因为栈的特点导致

以栈解决迷宫问题

怎么找到一个迷宫的出口呢.首先要知道迷宫长啥样,之后知道出入口,再之后就是找通路的过程了. 显然主要的部分是如何找通路.我们就举一个例子: 在这个迷宫中0就是墙,1就是路.那么我们可以用一个二维数组来表示这个迷宫.之后我们需要一种结构来实现我们表示位置的移动. struct Pos { size_t line; size_t row; }; 这个结构体通过记录行和列来表示现在处在迷宫的哪个位置. 现在就可以开始进行找通路的过程了.我们很容易想到通过试探当前位置的周围四个或三个位置来找到下一个应该

应用栈求解迷宫问题(C++实现)

栈是数据结构中一种重要的线性结构,限定仅在表尾进行插入和删除操作的线性表,因此我们也可以认为它是一种特殊的线性表.由于栈的这个特点,我们又可以称其为后进先出的结构.如图所示: 由于栈具有后进先出的性质我们可以利用,是程序设计中一个有用的工具.利用栈我们可以来实现数制转换.后缀表达式求值.迷宫求解等等.在书本上我们可以看到用C语言实现的简单思路,但是程序仍旧存在许多bug.今天,我想尝试用强大的C++来实现. 迷宫问题的求解思路大致则是从入口出发,顺着某一方向向前探索,若能走通,则继续向前探索:若

栈求解迷宫问题

求迷宫从入口到出口的所有路径是一个经典的程序设计问题.一般的设计思想就是从入口出发,顺着某个方向向下探索,探索分为上下左右四个方位,哪个方向是通的就将向下走,如果每个方向都走不下去就进行原路"回退".所以需要一个后进先出的结构来保存从入口到出口的路径.所以运用栈来实现是非常方便的,沿着某个方向走,将每个可通的位置进行入栈标记,再切换到下个位置:如果都不通,则栈顶出栈取消标记,再寻找.下来呢就实现一个简单的迷宫求解问题(求解出一条通路就好),至于求解多条通路并且求出最短路径的问题呢我还在