一.用栈来实现简单的迷宫
1. 迷宫:
回溯法:对一个包括有很多个结点,每个结点有若干个搜索分支的问 题,把原问题分解为若干个子问题求解的算法;当搜索到某个结点发 现无法再继续搜索下去时,就让搜索过程回溯(回退)到该节点的前一 个结点,继续搜索该节点外的其他尚未搜索的分支;如果发现该结点 无法再搜索下去,就让搜索过程回溯到这个结点的前一结点继续这样 的搜索过程;这样的搜索过程一直进行到搜索到问题的解或者搜索完 了全部可搜索分支没有解存在为止。
2.迷宫实现的简单步骤
(1.) 首先要初始化迷宫
(2.) 检测合法的迷宫入口(要求入口必须在迷宫的边界且为一 )
(3.)走迷宫(步骤是上.左.右.下)把每步走的路程赋值为2如果走的路行不通则标记为3
(4.)检测是否为迷宫出口(在边界且不和入口相等)
在实现代码时一定要注意前置头文件的声明
3.实现迷宫的代码
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.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.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;
}
if (ps->size == 0)
{
printf("栈已空!!!\n");
return;
}
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;
}
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");
}
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;
}