用栈实现的迷宫问题

迷宫问题中为了保证任何位置上都能沿原路退回，显然需要用一个先进后出的结果来保存从入口到当前位置的路径。因此，在迷宫通路的算法中应用“栈”也是自然而然的事情

头文件：

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define MYOVERFLOW -2
typedef int Status;
typedef struct{
    int x;      //通道块位置的横坐标
    int y;      //通道块位置的纵坐标
    char flag;  //通道块是否可行的标志
}PoseType;
typedef struct{
    int ord;         //通道块在路径上的”序号“
    PoseType seat;   //通道块在迷宫中的”坐标位置“
    int di;          //从此通道块走向下一通道块的”方向“
}SElemtype;          //栈的元素类型
typedef struct{
    SElemtype *base;//在栈构造之前和销毁之后，base的值为NULL
    SElemtype *top;//栈顶！d=====(￣▽￣*)b指针
    int stacksize;//当前已分配的空间储存，以元素为单位
}SqStack;
//-------基本操作的函数原型说明--------
Status visit(SqStack S);//对栈进行遍历
void Create_Stack(SqStack &S);//创建一个栈
Status InitStack(SqStack &S);//构造一个空栈S
Status DestroyStack(SqStack &S);//销毁栈S，S不再存在
Status ClearStack(SqStack &S);//把S置为空栈
Status StackEmpty(SqStack S);//若栈S为空栈，则返回TRUE，否则返回FALSE    
int StackLength(SqStack S);//返回S的元素个数，即栈的长度
Status GetTop(SqStack S, SElemtype &e);
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
Status Push(SqStack &S, SElemtype e);
//插入元素e为新的栈顶元素
Status Pop(SqStack &S, SElemtype &e);
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
Status StackTraverse(SqStack S, Status(*visit)(SqStack S));
//从栈底到栈顶依次对栈中每个元素调用函数visit（）一旦visit（）失败，则操作失败
void maze();//一个迷宫，求它从起点到终点的路径

上述操作的实现：

#include "stdafx.h"
Status InitStack(SqStack &S)//构造一个空栈S
{
    S.base = (SElemtype *)malloc(STACK_INIT_SIZE*sizeof(SElemtype));
    if (!S.base)exit(MYOVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}
Status DestroyStack(SqStack &S)//销毁栈S，S不再存在
{
    for (; S.top != S.base;){
        SElemtype *temp = S.top;
        S.top--;
        delete temp;
    }
    delete S.base;
    S.stacksize = 0;
    return OK;
}
Status ClearStack(SqStack &S)//把S置为空栈
{
    S.top = S.base;
    return OK;
}
Status StackEmpty(SqStack S)//若栈S为空栈，则返回TRUE，否则返回FALSE
{
    if (S.top == S.base)return TRUE;
    else return FALSE;
}
int StackLength(SqStack S)//返回S的元素个数，即栈的长度
{
    int length = 0;
    for (; S.top != S.base; S.top--)length++;
    return length;
}
Status GetTop(SqStack S, SElemtype &e)
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
{
    if (S.top != S.base){
        e = *(S.top - 1);
        return OK;
    }
    else return ERROR;

}
Status Push(SqStack &S, SElemtype e)
//插入元素e为新的栈顶元素
{
    if (S.top - S.base >= S.stacksize){
        S.base = (SElemtype *)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemtype));
        if (!S.base)exit(MYOVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *(S.top++) = e;
    return OK;
}
Status Pop(SqStack &S, SElemtype &e)
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
{
    if (S.top != S.base){
        e = *(--S.top);
        return OK;
    }
    else return ERROR;
}
Status visit(SqStack S)//对栈进行遍历1
{
    if (S.base){
        cout << "the data of the Stack is:";
        for (; S.top != S.base;)
        {
            --S.top;
            cout << S.top->di << " " << S.top->ord << " " << S.top->seat.x << ',' << S.top->seat.y <<S.top->seat.flag<< endl;
        }
        return OK;
    }
    else return ERROR;
}
Status StackTraverse(SqStack S, Status(*visit)(SqStack))
//从栈底到栈顶依次对栈中每个元素调用函数visit（）一旦visit（）失败，则操作失败
{
    if (visit(S))return OK;
    return ERROR;
}
void Create_Stack(SqStack &S)//创建一个栈
{
    InitStack(S);
    cout << "please input the length of the Stack:";
    int len;
    cin >> len;
    cout << "please input the data of the Stack:";
    for (int i = 1; i <= len; i++){
        SElemtype temp;
        cin >> temp.di>>temp.ord>>temp.seat.x>>temp.seat.y>>temp.seat.flag;
        Push(S, temp);
    }
}
void maze()//一个迷宫，求它从起点到终点的路径
{ 
    PoseType map[8][8];
    srand((int)time(0));
    for (int i = 0; i <= 7; i++)//构造地图
    {
        cout << "                         ";
        for (int j = 0; j <= 7; j++)
        {
            map[i][j].flag = 2;
            map[i][j].x = i;
            map[i][j].y = j;
            double ran = rand() / (RAND_MAX + 1.0);
            if (ran<= 0.7)map[i][j].flag = 1;//在这个地图中，墙所占的比例为30%
            cout << map[i][j].flag<< " ";
        }
        cout << endl;
    }
    cout << endl << endl << endl << endl;
    map[0][0].flag =0;//起点为地图的左上角
    map[7][7].flag = 1;//终点为地图的右下角
    int t = 1;//是迷宫路径上的第几块通道
    SqStack sq;
    InitStack(sq);//构造一个空的栈
    SElemtype first;
    first.di = 0;
    first.ord = t;
    first.seat = map[0][0];
    Push(sq, first);//将起点放到栈中
    do{
        SElemtype way, nextstep;
        Pop(sq,way);
        switch (way.di)
        {
        case 0:if (way.seat.y < 7 && map[way.seat.x][way.seat.y+1].flag==1){//如果上个通道块的di为0，则地图向右扩展
                   nextstep.di = 0;//新的通道块的di=0；是第++t个通道块，通道块的flag标志为0，说明此通道块被扩展
                   nextstep.ord = ++t;
                   map[way.seat.x][way.seat.y + 1].flag = 0;
                   nextstep.seat = map[way.seat.x][way.seat.y+1];
                   way.di++;//上个通道块的di++，说明右边的通道块已经被扩展
                   Push(sq, way);
                   Push(sq, nextstep);//将上个通道块和新的通道块都压入栈中
                   if (nextstep.seat.x == 7 && nextstep.seat.y == 7)goto label;//如果是终点，则跳出循环
                   break;
        }
               else {                                              //如果向右不能扩展，则di++，并将上个通道块压入栈
                   way.di++; Push(sq, way); break;
               }
        case 1:if(way.seat.x < 7 && map[way.seat.x+1][way.seat.y].flag == 1){//同case 0，这是向下扩展
                   nextstep.di = 0;
                   nextstep.ord = ++t;
                   map[way.seat.x+1][way.seat.y].flag = 0;
                   nextstep.seat = map[way.seat.x+1][way.seat.y];
                   way.di++;
                   Push(sq, way);
                   Push(sq, nextstep);
                   if (nextstep.seat.x == 7 && nextstep.seat.y == 7)goto label;
                   break;
        }
               else {
                   way.di++;
                   Push(sq, way); break;
               }
        case 2:if (way.seat.y >0 && map[way.seat.x ][way.seat.y- 1].flag == 1){//同case 0，这是向左扩展
                   nextstep.di = 0;
                   nextstep.ord = ++t;
                   map[way.seat.x][way.seat.y - 1].flag = 0;
                   nextstep.seat = map[way.seat.x][way.seat.y - 1];
                   way.di++;
                   Push(sq, way);
                   Push(sq, nextstep);
                   if (nextstep.seat.x == 7 && nextstep.seat.y == 7)goto label;
                   break;
        }
               else {
                   way.di++;
                   Push(sq, way); break;
               }
        case 3:if (way.seat.x > 0 && map[way.seat.x-1 ][way.seat.y].flag == 1){//同case 0，这是向上扩展
                   nextstep.di = 0;
                   nextstep.ord = ++t;
                   map[way.seat.x-1][way.seat.y].flag = 0;
                   nextstep.seat = map[way.seat.x-1 ][way.seat.y];
                   way.di++;
                   Push(sq, way);
                   Push(sq, nextstep);
                   if (nextstep.seat.x == 7 && nextstep.seat.y == 7)goto label;
                   break;
        }
               else {
                   way.di++;
                   Push(sq, way); break;
               }
        default:                                         //如果该通道块4个方向上已经被扩展完毕，则将这个通道块的flag设置为3，说明已经被扩展，但此路不通
                map[way.seat.x][way.seat.y].flag = 3;
                t--;
                break;
        }
    } while (!StackEmpty(sq));//当栈为空时，说明没有通路，跳出循环
    label:
    if (StackEmpty(sq)){ cout << "there is no way in the maze!"; exit(-1); }
    for (int i = 0; i <= 7; i++)
    {
        cout << "                         ";
        for (int j = 0; j <= 7; j++)
        {
            cout << map[i][j].flag << " ";
        }
        cout << endl;
    }
}

主函数：

// maze.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


int _tmain(int argc, _TCHAR* argv[])
{
    maze();
    return 0;
}

运行结果：

上述实心笑脸表示墙，空心笑脸表示此路可行，最终形成的空白是从起点到终点的通路