数据结构实验（2）：使用栈的方法求解迷宫从入口到出口的路径

题目：求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3

本题要求必须使用严格的搜索顺序，即从右，从下，从左，从上，并非要找到最短路径，例如上图我们得到的路径应该是：

所以应该得到程序结果为：

对于此题，数据结构老师要求使用栈的解法，一般首先想到的是动态规划，那栈的解法又该如何解决此问题呢？

首先参考到数据结构书关于这一部分的讲解：

作为一种不太好想到其实也并不优秀的解法，该如何去写这一题呢？

首先，进入一个位置，就将该位置压入栈中，该位置验证失败那就弹出该位置，如果成功完成，就修改标志，输出，结束。

优化：

①采用c++结构体定义Point，用于保存是否读写过，是否可以走，终点的信息。

②重载标准输出流，使得可以方便地输出(x,y)结构。

本题采用顺序栈，顺序栈代码在之前已有讲解，公众号回复栈即可获取相关讲解。

代码如下：

#include 
#include 
using namespace std;
struct Point
{
    int x, y;
    int data;
    int flag = 0;
    Point(int x = 0, int y = 0) : x(x), y(y) {}
}; //定义结构体
ostream &operator<<(ostream &out, const Point &p)
{
    out << '(' << p.x << ',' << p.y << ')';
    return out;
} //重载输出流，便于输出
//写栈操作
typedef struct
{
    int top;
    Point *base;
    int stacksize;
} sqstack; //定义栈
//初始化操作
int initstack(sqstack *s)
{
    s->base = (Point *)malloc(100 * sizeof(Point));
    if (!s->base)
        return -1; //提高鲁棒性
    s->top = 0;
    s->stacksize = 100;
    return 0;
}
//出栈
int pop(sqstack *s, Point *e)
{
    if (s->top == 0)
        return -1;
    *e = s->base[--s->top]; //pop会向后移位所以要先自减
    return 0;
}
//入栈
int push(sqstack *s, Point *p)
{
    if (s->top == s->stacksize)
    {
        s->base = (Point *)realloc(s->base, (s->stacksize + 1) * sizeof(Point));
        if (!s->base)
            return -1;
        s->stacksize++;
    }
    s->base[s->top++] = *p;
    return 0;
}
//摸顶
int gettop(sqstack *s, Point *e)
{
    if (!s->top)
        return -1;
    *e = s->base[s->top - 1];
    return 0;
}
sqstack sq;
Point map[15][15];
int flag=0;
void print()
{
    for (int i = 0; i < sq.top; i++)
    {
        cout << sq.base[i];
    }
}
void findways(Point *now, int mode)//从now以mode 走一步
{
    if (now->flag == 2)
    {
        push(&sq, now);
        print();
        flag=1;//标志
    }
    if (flag||now->data == 1 || now->flag == 1)
        return;
    push(&sq, now);
    now->flag = 1;
    int i = now->x;
    int j = now->y;
    switch (mode)
    {
    case 0:
        j++;
        break;
    case 1:
        i++;
        break;
    case 2:
        j--;
        break;
    case 3:
        i--;
        break;//用switch进行分流
    }
    for (int k = 0; k < 4&&!flag; k++)
        findways(&map[i][j], k);
    pop(&sq, now);
    return;
}
int main()
{
    initstack(&sq);//初始化栈
    int size;
    cin >> size;
    for (int i = 0; i < size; i++)
        for (int j = 0; j < size; j++)
        {
            cin >> map[i][j].data; //录入信息
            map[i][j].x = i;
            map[i][j].y = j;
        }
    map[size - 2][size - 2].flag = 2;
    for (int i = 0; i < 2; i++)
        findways(&map[1][1], i);//一开始第一步两种可能
    if(flag==0)cout<<"NO";
}

输出如上图结果，该结果是正确的。