迷宫查找有效路径C

//栈应用_迷宫问题
#include<stdio.h>
//内存分配函数需加载的头文件
#include<stdlib.h>
//宏定义迷宫数组最大行数
#define M 5
//宏定义迷宫数组最大列数
#define N 5
//定义方格结构类型
typedef struct
{
    //方格所在行行标
    int row;
    //方格所在列列标
    int column;
}box;
//定义方向结构类型
typedef struct
{
    //行标变化量
    int drow;
    //列标变化量
    int dcolumn;
}direction;
//定义栈结构类型
typedef struct
{
    //栈底指针
    box *base;
    //栈顶指针
    box *top;
    //栈容量
    int stacksize;
}Stack;
//栈的初始化
void initS(Stack &S,int n)
{
    //为栈分配存储空间
    S.base=(box *)malloc(sizeof(box)*n);
    //将栈置为空栈
    S.top=S.base;
    //设置栈容量
    S.stacksize=n;
}
//入栈
void push(Stack &S,box b)
{
    //判断栈是否已满
    if(S.top-S.base<S.stacksize)
    {
        //栈未满,将元素b压入栈顶
        *S.top=b;
        //栈顶指针上移
        S.top++;
    }
}
//出栈
box pop(Stack &S)
{
    //判断栈是否已空
    if(S.top!=S.base)
    {
        //栈未空 栈顶指针下移
        S.top--;
        return *S.top;
    }
}
//获取栈顶元素
box getTop(Stack S)
{
    //栈顶指针下移
    S.top--;
    //暂存栈顶元素
    box e;
    e=*S.top;
    //栈顶指针回溯
    S.top++;
    return e;
}
//迷宫二维数组
int maze[M][N]={
        {0, 1, 0, 0, 0},
        {0, 1, 0, 1, 0},
        {0, 0, 0, 1, 0},
        {0, 1, 1, 0, 0},
        {0, 0, 0, 0, 0}
};
//方向数组
direction directions[4]={
        {0,1},//向右移动 行标不变,列标+1
        {1,0},//向下移动 行标+1,列标不变
        {0,-1},//向左移动 行标不变,列标-1
        {-1,0}//向上移动  行标-1,列标不变
};
//判断方格状态是否合法
int isValid(box b)
{
    //方格是否在迷宫范围内及方格是否可通行
    return (b.row>=0&&b.row<M&&b.column>=0&&b.column<N&&maze[b.row][b.column]==0);
    /* 当maze[b.row][b.column]!=0时,有两种情况
     *  1.maze[b.row][b.column]==1 为墙体不可通行
     *  2.maze[b.row][b.column]==-1 已访问过
     * */
}
//查找是否存在有效路径
int findPath(box b,Stack &S)
{
    //将起点入栈
    push(S,b);
    //将起点标记为已访问
    maze[b.row][b.column]=-1;
    //当栈非空时,深度优先原则访问
    while(S.top!=S.base)
    {
        //current next当前方格及下一方格
        box current,next;
        //获取栈顶元素  此时无法判断栈顶元素是否在有效路径之中
        current= getTop(S);
        //判断当前方格是否为终点
        if(current.row==M-1&&current.column==N-1)
        {
            //此时栈中存储的便是有效路径的逆序
            return 1;
        }
        //当前方格开始尝试不同的移动方向
        int di;
        di=0;
        while(di<4)
        {
            //计算下一方格的行标 列标
            next.row=current.row+directions[di].drow;
            next.column=current.column+directions[di].dcolumn;
            //判断下一方格是否可通行
            if(isValid(next))
            {
                //将下一方格入栈
                push(S,next);
                //将下一个方格标记为已访问
                maze[next.row][next.column]=-1;
                //跳出while循环去处理下一个方格
                break;
            }
            else
            {
                //尝试其他方向
                di++;
            }
        }
        //当di==4时,说明四个移动方向均不合适 则此时栈顶元素便不是有效路径 出栈
        pop(S);
    }
    //当栈空时,说明不存在有效路径
    return 0;
}
void printPath(int n)
{
    Stack  S;
    initS(S,n);
    box  b;
    b.row=b.column=0;
    if(findPath(b,S))
    {
        printf("有效路径如下:\n");
        while(S.top!=S.base)
        {
            box e;
            e= pop(S);
            printf("row:%-2d,column:%-2d\n",e.row,e.column);
        }
    }
    else
    {
        printf("不存在有效路径!\n");
    }
}