栈结构实现：迷宫出口判断

利用栈实现迷宫：首先判断入口是否合法。入栈，保存栈顶位置并判断是否为出口。走过的位置标记为2。如果不是出口，
依次向上-左-右-下的方向判断是否走得通，走不通可返回，返回时标记为3.若是四个方向
都走不通，说明迷宫无出口！

stack.h

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

typedef struct Position DataType;

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

// 栈的初始化 
void StackInit(Stack *S, int capacity);

// 入栈 
void StackPush(Stack *S, DataType data);

// 出栈 
void StackPop(Stack *S);

// 获取栈顶元素 
DataType StackTop(Stack *S);

// 获取栈中元素个数 
void StackSize(Stack *S);

// 检测栈是否为空 
int StackEmpty(Stack *S);

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;

// 栈的初始化 
void InitMaze(Maze *m, int map[][MAX_COL]);

// 检测入口是否为有效入口 
int IsValidEntry(Maze *m, Position entry);

// 检测cur位置是否是通路 
int IsPass(Maze *m, Position cur);

// 检测Cur是否在出口 
int IsExit(Maze *m, Position cur, Position entry);

// 走迷宫 
void PassMaze(Maze *m, Position entry, Stack *s);

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

Stack.c

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

void StackInit(Stack *S,int capacity)//栈初始化
{
	S->arr = (DataType*)malloc(capacity*sizeof(DataType));
	if(NULL == S->arr)
	{
	   printf("申请空间失败！\n");
	   return;
	}
	S->capacity = capacity;
	S->size = 0;
}


void AddCapacity(Stack *S)//扩容
{
   if(NULL == S->arr)
	{
	   printf("扩容失败\n");
	   return;
	}
   S->capacity = (DataType*)realloc(S->arr,sizeof(DataType)*(S->capacity)*2);//扩容为原来的二倍
   if (NULL == S->arr)
    {
        printf("空间扩增失败!!!\n");
        return;
    }
   S->capacity =2 * (S->capacity);
}

void PrintfStack(Stack *S)//打印栈
{
   int i = 0;
   if(NULL == S->arr)
	{
	   printf("打印失败\n");
	   return;
	}
   for(;i<S->size;i++)
   {
	   printf("%d\n",S->arr[i]);
   }
   printf("\n");
}

void StackPush(Stack *S,DataType data)//入栈
{
	if(NULL == S->arr)
	{
	   printf("入栈失败\n");
	   return;
	}
	if(S->capacity == S->size)//空间已满
	{
	   AddCapacity(S);
	}
	S->arr[S->size] = data;
	S->size++;
}

void StackPop(Stack *S)//出栈
{
   if(NULL == S->arr)
	{
	   printf("出栈失败\n");
	   return;
	}
   S->size--;
}

DataType StackTop(PStack P)//获取栈顶元素
{
	return P->arr[P->size - 1];
  /* int ret = 0;
   if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return;
	}
   if(0 == S->size)
   {
   printf("栈为空！\n");
   return;
   }
  
   printf("栈顶元素为：%d \n", S->arr[S->size - 1]);*/
}

void StackSize(Stack *S)//获取元素个数
{
   if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return;
	}
   printf("元素个数为：%d\n",S->size);
}

int StackEmpty(Stack *S)//检测栈是否为空
{
    if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return 0;
	}
	if(S->size == 0)
	{
	printf("栈为空\n");
	return 1;
	}
	return 0;
}

Maze.c

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

//1. 用栈对简单迷宫进行求解，迷宫只有一个出口
//采用循环方式实现

void PrintMaze(Maze *m)//打印迷宫
{
    int i = 0;
    assert(m);

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

}

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

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

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

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

int IsPass(Maze *m, Position cur)// 检测cur位置是否是通路 
{
    assert(m);

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

    return 0;

}

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

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

    return 0;
}

void PassMaze(Maze *m, Position entry, Stack *s)//寻找出口
{
    Position cur;
    Position next;
    assert(m);
    assert(s);
    if (!IsValidEntry(m, entry))//检测入口是否合法
    {
        printf("迷宫入口不合法!!!\n");
        return;
    }

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

    while (!StackEmpty(s))
    {
        cur = StackTop(s);//保存栈顶位置，判断每个方向是必须重新赋值
        if (IsExit(m, cur, entry))//判断是否为出口
        {
            m->_map[cur._x][cur._y] = 2;
            printf("已找到出口!!!\n");
            return;
        }
        m->_map[cur._x][cur._y] = 2;//走过的路赋2

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

        //判断是否可以走通
        if (IsPass(m, next))
        {
            StackPush(s, next);
            continue;//进行下一次循环
        }

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

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

        //下
        next = cur;
        next._x += 1;
        if (IsPass(m, next))
        {
            StackPush(s, next);
            continue;
        }
        m->_map[cur._x][cur._y] = 3;//如果上下左右都不能走通，那么说明cur走错了，标记为3，出栈
        StackPop(s);
    }
    printf("迷宫没有出口!!!\n");//走到这，说明找不到迷宫出口
}

TestMaze()

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

void TestMaze()
{
    Position entry;
    Maze m;
	Stack s;
    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 } };
	StackInit(&s, 10);
    InitMaze(&m, map);
    PrintMaze(&m, map);
    entry._x = 5;
    entry._y = 2;
    PassMaze(&m, entry, &s);
    printf("\n");
    PrintMaze(&m, map);


}
int main()
{
    

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

栈结构实现：迷宫出口判断

猜你喜欢