栈应用之简单迷宫问题（C语言版）

迷宫在这儿——–>（用二维数组实现）
栈的应用有很多，前面解决了括号问题和后缀表达式问题，迷宫便可以解决了！！
迷宫的解题思路有点绕，并且其栈的结构也有所改变！但是本次解决迷宫仍然用的普通的栈

首先：迷宫如下（1表示通路，0表示非通路）

0  0  0  0  0  0 
0  0  1  0  0  0 
0  0  1  0  0  0 
0  0  1  1  1  0 
0  0  1  0  1  1 
0  0  1  0  0  0 

解题思路：

迷宫结构，以及位置结构

typedef struct Position           //位置结构体
{
    int _x;
    int _y;
}Position;

#define MAX_ROW 6
#define MAX_COL 6 

typedef struct Maze            //迷宫结构体
{
    int _map[MAX_ROW][MAX_COL];   //一张地图

}Maze;

一些辅助判断函数

//初始化位置
void PositionInit(Position* pos, int row, int col)
{
    assert(pos);

    pos->_x = row;
    pos->_y = col;
}
//初始化迷宫
void MazeInit(Maze* m, int map[][MAX_COL])
{
    assert(m);                        //参数检测

    int i = 0, j = 0;

for (i = 0; i < MAX_ROW; i++)           //遍历赋值
{
    for (j = 0; j < MAX_COL; ++j)
    {
        m->_map[i][j] = map[i][j];
    }
    }
}
//打印迷宫
void MazePrint(Maze* m, int map[][MAX_COL])
{
    assert(m);                     //参数检测

    int i = 0, j = 0;

for (i = 0; i < MAX_ROW; ++i)         //遍历打印
{
    for (j = 0; j < MAX_COL; ++j)
    {
        printf("%d ", m->_map[i][j]);
    }
    printf("\n");
    }
}
//判断是否为合理入口
int IsValidEntry(Maze* m, Position now)
{
    assert(m);                            //参数检测

if (now._x == 0 || now._x == MAX_ROW - 1 ||         //入口合理的条件（四个）
    now._y == 0 || now._y == MAX_COL - 1)
{
    if (m->_map[now._x][now._y] == 1)
    return 1;
}
return 0;
}
//判断是否为通路
int IsPass(Maze* m, Position next)
{
    if (m->_map[next._x][next._y] == 1)            //下一个位置元素为1，即为通路
        return 1;
    return 0;
}
//判断是否为出口
int IsExit(Maze* m, Position now, Position entry)
{
    if (now._x == 0 || now._x == MAX_ROW - 1 ||                        //入口合理的条件（四个）
        now._y == 0 || now._y == MAX_COL - 1 )                         //出口和入口的条件一致
    {
        if (now._x != entry._x && now._y != entry._y)                  //出口不能和入口是同一个
            return 1;
    }
    return 0;
}

划重点！！！—->走迷宫函数（循环法）

//走迷宫(循环法)（简单迷宫）
void PassMaze(Maze* m, Position entry, Stack* s)
{
    assert(m);                       //参数检测

Position _now, _next;            //创建当前位置和下一个位置

if (!IsValidEntry(m, entry))                        //判断入口是否合理
{
    printf("迷宫入口不合理！！ \n");
    return;
}

StackPush(s, (entry._x * MAX_ROW) + entry._y);          //入栈入口
_now = entry;
while (!IsExit(m, _now, entry))                          //当前步不是出口--->进入循环
{
    _now._x = StackTop(s) / MAX_COL;                     //将当前步改为栈顶位置
    _now._y = StackTop(s) % MAX_COL;
    m->_map[_now._x][_now._y] = 2;
    if (IsExit(m, _now, entry))                          //判断是否出口
        return;

    //往上走
    _next = _now;                                         //找到下一步，判断是否为通路，是则入栈，并且该位置元素改为2
    _next._x -= 1;
    if (IsPass(m, _next))
    {
        StackPush(s, (_next._x * MAX_ROW) + _next._y);
        m->_map[_next._x][_next._y] = 2;
        continue;
    }
    //往左走
    _next = _now;
    _next._y -= 1;
    if (IsPass(m, _next))
    {
        StackPush(s, (_next._x * MAX_ROW) + _next._y);
        m->_map[_next._x][_next._y] = 2;
        continue;
    }
    //往右走
    _next = _now;
    _next._y += 1;
    if (IsPass(m, _next))
    {
        StackPush(s, (_next._x * MAX_ROW) + _next._y);
        m->_map[_next._x][_next._y] = 2;
        continue;
    }
    //往下走
    _next = _now;
    _next._x += 1;
    if (IsPass(m, _next))
    {
        StackPush(s, (_next._x * MAX_ROW) + _next._y);
        m->_map[_next._x][_next._y] = 2;
        continue;
    }

    StackPop(s);                                                    //走到死胡同，该位置是错误的，将其出栈，并且将该位置元素改为3
    m->_map[_now._x][_now._y] = 3;
}
}

测试结果：

另外
1、该迷宫有优化之处！！今后会优化一次！！
2、其他栈应用问题，大家可以看主页！！！
3、关于栈的基础操作，附上链接：https://blog.csdn.net/code_zx/article/details/80812635
4、谢谢！！！！