数据结构应用实例#栈#迷宫寻路

使用数据结构 栈（Stack）来实现一种低级的迷宫寻路的功能。
低级是因为无法判断路径是不是最短的。

这里使用的栈结构如图 (这图我选择死亡...)

注意结构体里DataType的实际含义，是另外一个结构体，用于储存二维位置x，y

地图使用一个10x10的二维数组来表示，数字1表示该点是墙壁，0表示可以行走，2表示已经走过的地方。

我们用栈来储存走过的位置，比如我们从起点(4,0)出发，就把(4,0)压入栈，并把该点数值改为2，意为已经来过了。
如果遇到死路，那就不停地出栈，直到栈顶的这个点周围有路可走为止。

逻辑部分伪代码如下

while(没有到达终点)
{
　　if(上下左右四个方向有路可走)
　　{
　　　　将可以走的那个位置（不是当前位置！）压入栈
　　}
　　else
　　{
　　　　出栈
　　}
}

#include <stack>
#include <iostream>

using std::cout;
using std::endl;
using std::stack;

const int MAZEWIDTH = 10;
const int MAZEHEIGHT = 10;

//0可走
//1墙
//2走过
//3走过又退回来了
int Maze[MAZEWIDTH][MAZEHEIGHT] = {
        //0  1  2  3  4  5  6  7  8  9
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,//0
        1, 0, 1, 0, 0, 0, 1, 0, 0, 0,//1
        1, 0, 0, 0, 1, 0, 1, 0, 0, 1,//2
        1, 0, 1, 1, 0, 0, 1, 1, 0, 1,//3
        1, 0, 1, 0, 0, 1, 0, 1, 0, 1,//4
        0, 0, 1, 1, 0, 1, 0, 0, 0, 1,//5
        1, 1, 0, 0, 0, 0, 1, 0, 1, 1,//6
        1, 0, 1, 1, 1, 0, 1, 0, 0, 1,//7
        1, 0, 0, 0, 0, 0, 0, 0, 0, 1,//8
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1//9
};

struct _XY {
    int x, y;

    _XY() {
        x = y = 0;
    }

    _XY(int a, int b) : x(a), y(b) { }

    int operator==(const struct _XY &a) {
        return (a.x == x) && (a.y == y);
    }
};

typedef _XY XY;

class MazeBreaker {
private:
    int MazeMap[MAZEWIDTH][MAZEHEIGHT];
    stack<XY> path;
    XY start, end;


    void push(XY xy) {
        path.push(xy);
        MazeMap[xy.x][xy.y] = 2;
    }

    void push(int x, int y) {
        path.push(XY(x, y));
        MazeMap[x][y] = 2;
    }

    void pop() {
        if (!(path.top() == start)) {
            XY &loc = path.top();
            MazeMap[loc.x][loc.y] = 3;
            path.pop();
        }
    }

    int End() {
        return path.top() == end;
    }

    void ThereIsAWay() {
        XY &loc = path.top();
        //UP
        if (MazeMap[loc.x - 1][loc.y] == 0) {
            push(loc.x - 1, loc.y);
            return;
        }
        //RIGHT
        if (MazeMap[loc.x][loc.y - 1] == 0) {
            push(loc.x, loc.y - 1);
            return;
        }
        //DOWN
        if (MazeMap[loc.x + 1][loc.y] == 0) {
            push(loc.x + 1, loc.y);
            return;
        }
        //LEFT
        if (MazeMap[loc.x][loc.y + 1] == 0) {
            push(loc.x, loc.y + 1);
            return;
        }
        pop();
        return;
    }

public:

    void GenerateMap() {
        for (int lop = 0; lop < MAZEWIDTH; lop++) {
            for (int lop2 = 0; lop2 < MAZEHEIGHT; lop2++) {
                MazeMap[lop][lop2] = Maze[lop][lop2];
            }
        }
        push(start);
    }

    MazeBreaker() {
        start.x = 5;
        start.y = 0;
        end.x = 1;
        end.y = 9;
    }

    void FindPath() {
        while (!End()) {
            ThereIsAWay();
        }

        for (int lop = 0; lop < MAZEWIDTH; lop++) {
            for (int lop2 = 0; lop2 < MAZEHEIGHT; lop2++) {
                if (MazeMap[lop][lop2] == 2) {
                    cout << "O";
                } else if (MazeMap[lop][lop2] == 3) {
                    cout << "X";
                } else {
                    cout << " ";
                }
            }
            cout << endl;
        }
    }

};

int main() {
    MazeBreaker mb;
    mb.GenerateMap();
    mb.FindPath();
    return 0;
}

///////////以下是老版本////////////

首先是栈的头文件，注意栈结构体内容的具体定义

Stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include<stdio.h>
#include<stdlib.h>

//以下两个数据大小视实际情况而定
//初始栈容量
#define STACK_INIT_SIZE 20
//每次扩容的增量
#define STACKINCREMENT 10

//迷宫地图
int Maze[10][10];

//表示位置
struct xy
{
    int x, y;
};
typedef struct xy XY;
typedef  XY DataType;

struct stack
{
    //指向栈最顶上的元素的接下来一个位置
    //表示新入栈的值可以放在指向的地方
    DataType *Top;
    //指向栈底部，最里面的元素
    DataType *Bottom;
    //表示了当前栈的容量
    int stacksize;
};
typedef struct stack STACK;

//新建栈
int InitStack(STACK *S);

//销毁栈
int DestroyStack(STACK *S);

//返回顶层元素
int GetTop(STACK S,int *x,int *y);

//Push操作，入栈，压栈
int Push(STACK *S, int x,int y);

//Pop操作，出栈
int Pop(STACK *S);

#endif

然后是定义

Stack.c

#include"Stack.h"

int InitStack(STACK *S)
{
    //创建出设定长度的顺序表，地址赋给bottom指针
    S->Bottom = (DataType*)malloc(STACK_INIT_SIZE*sizeof(DataType));
    if (!S->Bottom)
    {
        return 0;
    }
    S->stacksize = STACK_INIT_SIZE;
    S->Top = S->Bottom;
    return 1;
}

int DestroyStack(STACK *S)
{
    S->Top = NULL;
    free(S->Bottom);
    S->Bottom = NULL;
    return 1;
}

int GetTop(STACK S, int *x, int *y)
{
    if (S.Bottom != S.Top)
    {
        //由于top指向的是最顶上元素的下一个位置
        //所以取出最顶上元素的时候
        //要把top减去1
        *x = ((S.Top - 1)->x);
        *y = ((S.Top - 1)->y);
        return 1;
    }
    return 0;
}

int Push(STACK *S, int x,int y)
{
    //当超出当前栈的容量时
    //这里应该只有等于的情况
    //而不会大于
    if ((S->Top - S->Bottom) >= S->stacksize)
    {
        //realloc函数将开辟指定的储存空间
        //并将原来的数据全部移到这个新的储存空间
        S->Bottom = (DataType*)realloc(S->Bottom, (S->stacksize + STACKINCREMENT)*sizeof(DataType));
        if (!S->Bottom)
        {
            return 0;
        }
        //由于重新开辟了空间
        //需要重新根据bottom指针的位置指定top
        S->Top = S->Bottom + S->stacksize;
        //最后增加当前栈容量
        S->stacksize += STACKINCREMENT;
    }
    //再把入栈的数据存放好
    (S->Top)->x = x;
    (S->Top)->y = y;
    S->Top++;

    //在地图上将该点标为2
    Maze[x][y] = 2;
    return 1;
}

//将该点丢弃
int Pop(STACK *S)
{
    if (S->Bottom == S->Top)
    {
        printf("Empty Stack!Can not pop!
");
        return 0;
    }
    //top指针先减1再取值
    --S->Top;
    return 1;
}

寻路的逻辑放在了main函数里，迷宫地图的定义也在这里

main.c

二维数组Maze存放了迷宫的信息，你也可以自己改改*。

#include"Stack.h"

#define Up 1
#define Right 2
#define Down 3
#define Left 4
//代表已无路可走
//End of Road
#define EOR 5

//迷宫的地图
//墙壁表示为1，可走的地方表示为0，走过的地方表示为2
//入口为(4,0)，出口为(0,8)
//可自行更改，但请确保有通路

Maze[10][10] = { 
//0,1,2,3,4,5,6,7,8,9
1,1,1,1,1,1,1,1,0,1,     //0
1,0,0,0,0,0,0,1,0,1,     //1
1,0,1,0,1,1,1,1,0,1,     //2
1,0,1,0,1,0,0,0,0,1,     //3
0,0,1,0,1,0,1,0,1,1,     //4
1,0,1,0,1,0,1,0,1,1,     //5
1,1,0,0,1,0,1,0,1,1,     //6
1,0,0,1,1,0,1,0,1,1,     //7
1,0,0,0,0,0,1,0,0,1,     //8
1,1,1,1,1,1,1,1,1,1 };  //9

//打印结果
int Print()
{
    int lop, lop2;
    for (lop = 0; lop < 10; lop++)
    {
        for (lop2 = 0; lop2 < 10; lop2++)
        {
            if (Maze[lop][lop2] == 2)
            {
                printf("1");
            }
            else
            {
                printf(" ");
            }
        }
        printf("
");
    }
    return 1;
}

int GameOver(STACK s, XY *loc,XY End)
{
    GetTop(s, &(loc->x), &(loc->y));
    if (loc->x == End.x && loc->y == End.y)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//1 up.2 right.3 down.4 left
//看看当前位置的上下左右还有没有能走的地方
int SearchPath(STACK s, XY loc)
{
    int x, y;
    x = loc.x;
    y = loc.y;

    //Up Available?
    if (x != 0)
    {
        if (!Maze[x - 1][y])
        {
            return Up;
        }
    }
    //Right ?
    if (y != 9)
    {
        if (!Maze[x][y + 1])
        {
            return Right;
        }
    }
    //Down?
    if (x != 9)
    {
        if (!Maze[x + 1][y])
        {
            return Down;
        }
    }
    //Left?
    if (y != 0)
    {
        if (!Maze[x][y - 1])
        {
            return Left;
        }
    }
    return EOR;
}

int main()
{
    //储存走出迷宫的路径
    STACK Path;
    //储存当前位置
    XY loc;
    //起点终点的位置
    XY Start = { 4,0 }, End = { 0,8 };

    InitStack(&Path);
    //将起点入栈
    Push(&Path, Start.x, Start.y);

    //开始
    while (!GameOver(Path, &loc, End))
    {
        switch (SearchPath(Path, loc))
        {
        case Up:
            Push(&Path, loc.x - 1, loc.y);
            break;
        case Right:
            Push(&Path, loc.x, loc.y + 1);
            break;
        case Down:
            Push(&Path, loc.x + 1, loc.y);
            break;
        case Left:
            Push(&Path, loc.x, loc.y - 1);
            break;
        case EOR:
            Pop(&Path);
            break;
        default:
            printf("Shit Happened! Check your code!
");
            break;
        }
    }
    Print();
    DestroyStack(&Path);
    return 0;
}

最后运行结果如图

有一行多出来的1，因为打印的是走过的路径。

*如果你想自己更改迷宫地图的话，请务必记得更改相应的起点和终点（114行）