栈的应用--简单迷宫

测试环境：vs2013

Maze.h

#pragma once
#define MAX_ROW 6
#define MAX_COL 6

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

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

}Maze, *PMaze;

//1. 用栈对简单迷宫进行求解，迷宫只有一个出口
//采用循环方式实现
// 栈的初始化 
void InitMaze(PMaze pm, int map[][MAX_COL]);

// 检测入口是否为有效入口 
int IsValidEntry(PMaze pm, Position entry);

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

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

// 走迷宫 
void PassMaze(PMaze pm, Position entry, PStack ps);

// 打印迷宫 
void PrintMaze(PMaze m, int map[][MAX_COL]);

Stack.h

#pragma once
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


extern  struct Position;
typedef struct Position DataType;

typedef struct Stack
{
    DataType *arr;//指向动态空间的指针
    int capacity;//空间总容量
    int size;//有效元素个数
}Stack,* PStack;

// 栈的初始化 
void StackInit(PStack ps, int capacity);

// 入栈 
void StackPush(PStack ps, DataType data);

// 出栈 
void StackPop(PStack ps);

// 获取栈顶元素 
DataType StackTop(PStack ps);

// 获取栈中元素个数 
int StackSize(PStack ps);

// 检测栈是否为空 
int StackEmpty(PStack ps);

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;
}

void PassMaze(PMaze pm, Position entry, PStack ps)
{
    Position cur;
    Position next;
    assert(pm);
    assert(ps);

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

    //走进入口,入栈
    StackPush(ps, entry);

    while (!StackEmpty(ps))
    {
        cur = StackTop(ps);

        //在标记之前检测要不然，cur位置值不为1
        if (IsExit(pm, cur, entry))
        {
            pm->_map[cur._x][cur._y] = 2;
            printf("已找到出口!!!\n");
            return;
        }
        pm->_map[cur._x][cur._y] = 2;

        //依次判断上下左右是否可以走通
        //上
        next = cur;
        next._x -= 1;

        //判断是否可以走通
        if (IsPass(pm, next))
        {
            StackPush(ps, next);
            continue;
        }

        //左
        next = cur;//如果走到这，next值已经变了，所以要重新赋值
        next._y -= 1;
        if (IsPass(pm, next))
        {
            StackPush(ps, next);
            continue;
        }

        //右
        next = cur;
        next._y += 1;
        if (IsPass(pm, next))
        {
            StackPush(ps, next);
            continue;
        }

        //下
        next = cur;
        next._x += 1;
        if (IsPass(pm, next))
        {
            StackPush(ps, next);
            continue;
        }

        //如果上下左右都不能走通，那么说明cur走错了，标记为3，出栈
        pm->_map[cur._x][cur._y] = 3;
        StackPop(ps);
    }

    //走到这，说明找不到迷宫出口
    printf("迷宫没有出口!!!\n");
}

Stack.c

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

//初始化栈，有效元素清空，分配起始空间
void StackInit(PStack ps, int capacity)
{
    if (NULL == ps)
        return;

    ps->arr = (DataType *)malloc(sizeof(DataType)*capacity);

    if (NULL == ps->arr)
    {
        printf("申请空间失败!!!\n");
        return;
    }

    ps->capacity = capacity;//空间容量改变
    ps->size = 0;//有效元素清空

}

void AddCapacity(PStack ps)
{
    if (NULL == ps)
        return;

    ps->arr = (DataType *)realloc(ps->arr, sizeof(DataType)*(ps->capacity) * 2);//扩增位原空间大小二倍

    if (NULL == ps->arr)
    {
        printf("空间扩增失败!!!\n");
        return;
    }

    ps->capacity = 2 * (ps->capacity);

}

void PrintStack(PStack ps)
{
    int i = 0;
    if (NULL == ps)
        return;

    for (; i < ps->size; i++)
    {
        printf("%d ", ps->arr[i]);
    }
    printf("\n");
}

//入栈，就是对表进行尾插
void StackPush(PStack ps, DataType data)
{
    if (NULL == ps)
        return;

    if (ps->size == ps->capacity)//说明空间已满，要申请空间
        AddCapacity(ps);

    ps->arr[ps->size] = data;
    ps->size++;

}

void StackPop(PStack ps)
{
    if (NULL == ps)
        return;

    if (ps->size == 0)
    {
        printf("栈已空，操作失败!!!\n");
        return;
    }

    ps->size--;
}

// 获取栈顶元素,栈顶就是表的尾部
DataType StackTop(PStack ps)
{
    //if (NULL == ps)
    //{
    //  printf("栈不存在!!!\n");
    //  return 0;
    //}

    //if (ps->size == 0)
    //{
    //  printf("栈已空!!!\n");
    //  return 0;
    //}

    return ps->arr[ps->size - 1];
}

// 获取栈中元素个数 
int StackSize(PStack ps)
{
    if (NULL == ps)
    {
        printf("栈不存在!!!\n");
        return 0;
    }

    return ps->size;
}

// 检测栈是否为空 
int StackEmpty(PStack ps)
{
    if (NULL == ps)
    {
        printf("栈不存在!!!\n");
        return 0;
    }

    if (ps->size)
        return 0;
    return 1;

}

test.c

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

void TestMaze(PStack ps)
{
    int i = 0;
    Position entry;
    Maze m;
    PMaze pm = &m;
    StackInit(ps, 10);
    int map[6][6] = { { 0, 0, 0, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0 },
    { 0, 0, 1, 1, 1, 0 },
    { 0, 0, 1, 0, 1, 1 },
    { 0, 0, 1, 0, 0, 0 } };
    InitMaze(pm, map);
    PrintMaze(pm, map);
    entry._x = 5;
    entry._y = 2;
    PassMaze(pm, entry, ps);
    printf("\n");
    PrintMaze(pm, map);


}
int main()
{
    Stack s;
    PStack ps = &s;

    TestMaze(ps);//测试迷宫
    system("pause");
    return 0;
}