简单迷宫的递归求解及大致栈帧结构

测试环境：vs2013

Maze.h

#pragma once
#define MAX_ROW 4
#define MAX_COL 4

typedef struct Position
{
    int _x;
    int _y;
}Position;

typedef struct Maze
{
    int _map[MAX_ROW][MAX_COL];

}Maze, *PMaze;


void InitMaze(PMaze pm, int map[][MAX_COL]);
int IsValidEntry(PMaze pm, Position entry);
int IsPass(PMaze pm, Position cur);
int IsExit(PMaze pm, Position cur, Position entry);

// 真正走迷宫函数 
int _PassMaze(PMaze pm, Position entry, Position cur, PStack ps);

// 提供给用户使用的走迷宫函数，与上上个走迷宫函数的区别是：用户不用去传当前步，只需要给入口就行 
void PassMaze(PMaze pm, Position entry, PStack ps);
void PrintMaze(PMaze pm, int map[][MAX_COL]);

Maze.c

#include "stack.h"
#include "Maze.h"

//打印迷宫
void PrintMaze(PMaze pm)
{
    int i = 0;
    assert(pm);

    for (; i < MAX_ROW; ++i)
    {
        int j = 0;
        for (; j < MAX_COL; ++j)
        {
            printf("%d ", pm->_map[i][j]);
        }
        printf("\n");
    }

}

//迷宫初始化,就是将地图中的值赋给迷宫
void InitMaze(PMaze pm, int map[][MAX_COL])
{
    int i = 0;
    assert(pm);

    for (; i < MAX_ROW; ++i)
    {
        int j = 0;
        for (; j < MAX_COL; ++j)
        {
            pm->_map[i][j] = map[i][j];
        }
    }
}

//检测迷宫入口是否合法
int IsValidEntry(PMaze pm, Position entry)
{
    assert(pm);

    //必须位于迷宫边界且值为1
    if ((entry._x == 0 || entry._y == 0 || entry._x == MAX_ROW - 1
        || entry._y == MAX_COL - 1) && (pm->_map[entry._x][entry._y] == 1))
        return 1;
    return 0;
}

// 检测cur位置是否是通路 
int IsPass(PMaze pm, Position cur)
{
    assert(pm);

    //值为1且不能越界
    if ((cur._x >= 0 && cur._x <= MAX_ROW - 1) &&
        (cur._y >= 0 && cur._y <= MAX_COL - 1) &&
        pm->_map[cur._x][cur._y] == 1)
        return 1;

    return 0;

}

// 检测Cur是否在出口 
int IsExit(PMaze pm, Position cur, Position entry)
{
    assert(pm);

    //出口位置就是处于边界值为1且不能是入口
    if ((cur._x == 0 || cur._y == 0 || cur._x == MAX_ROW - 1
        || cur._y == MAX_COL - 1) && (pm->_map[cur._x][cur._y] == 1)
        && ((cur._x != entry._x) || (cur._y != entry._y)))
        return 1;

    return 0;
}

// 真正走迷宫函数 
int _PassMaze(PMaze pm, Position entry, Position cur, PStack ps)
{

    Position next;
    assert(pm);
    assert(ps);

    //先判断当前位置是否是通路
        if (IsPass(pm, cur))
        {
            //先入栈，再判断是不是出口，最后标记，因为如果是出口，标记完就不是1
            StackPush(ps, cur);
            if (IsExit(pm, cur, entry))
            {
                pm->_map[cur._x][cur._y] = 2;
                return 1;
            }
            pm->_map[cur._x][cur._y] = 2;

            // up，直接走，进入函数后再判断是否能走通
            next = cur;
            next._x -= 1;
            if (_PassMaze(pm, entry, next, ps))
                return 1;

            // left
            next = cur;
            next._y -= 1;
            if (_PassMaze(pm, entry, next, ps))
                return 1;

            // right
            next = cur;
            next._y += 1;
            if (_PassMaze(pm, entry, next, ps))
                return 1;

            // down
            next = cur;
            next._x += 1;
            if (_PassMaze(pm, entry, next, ps))
                return 1;

            //四个方向都走不通，说明cur走错了，标记位3出栈
            pm->_map[cur._x][cur._y] = 3;
            StackPop(ps);
        }

        return 0;

}



//提供给用户使用的走迷宫函数，与上个走迷宫函数的区别是：用户不用去传当前步，只需要给入口就行
void PassMaze(PMaze pm, Position entry, PStack ps)
{
    assert(pm);
    assert(ps);

    //检测入口是否合法
    if (!IsValidEntry(pm, entry))
    {
        printf("迷宫入口不合法!!!\n");
        return;
    }

    //合法就走入迷宫
    _PassMaze(pm, entry, entry, ps);
}

test.c

#include "stack.h"
#include "Maze.h"
#include <windows.h>


    Position entry;
    Maze m;
    PMaze pm = &m;
    StackInit(ps, 10);

int map[4][4] = { { 0, 0, 0, 0 },
                      { 0, 1, 0, 0 },
                      { 0, 1, 1, 1 },
                      { 0, 1, 0, 0 }};
    InitMaze(pm, map);
    PrintMaze(pm, map);
    entry._x = 3;
    entry._y = 1;
    PassMaze(pm, entry, ps);//简单迷宫递归    printf("\n");
    PrintMaze(pm, map);


}
int main()
{
    Stack s;
    PStack ps = &s;
    //TestStack(ps);
    //Test1(ps);//括号匹配，逆波兰表达式
    TestMaze(ps);//测试迷宫

    system("pause");
    return 0;
}

在递归过程中函数的栈帧结构大致如下：