1,栈的基本操作和迷宫的数据结构
#include<iostream>
using namespace std;
#define STACK_INIT_SIZE 100
#define STACK_INCREMENT_SIZE 100
typedef struct{
int x,y;
}PostType;//坐标结构
typedef struct
{
int order;//通道快在路径上的序号[1,n]
PostType seat;//通道快的坐标
int direction;//方向,1,2,3,4,分别表示东西南北
}Block;//栈元素的类型
typedef Block ElemType;
typedef struct{
ElemType *base;//栈底指针,总是指向栈底
ElemType *top;//栈顶指针,总是指向最上元素的上一个位置
int size;//栈的大小
}SqStack;
//-----基本操作-----
int InitStack(SqStack &S)
{//构造一个空栈
S.base = new ElemType[100];
if(!S.base) return 0;
S.top=S.base;
S.size=STACK_INIT_SIZE;
return 1;
}
int StackEmpty(SqStack S)
{//判断S是否为空,为空返回1
if(S.base==S.top)return 1;
else return 0;
}
int GetTop(SqStack S,ElemType &e)
{
if(S.base==S.top) return 0;
e= *(S.top-1);
return 1;
}
int Push(SqStack &S,ElemType e)
{
if(S.top-S.base>=S.size)
{
S.base = new ElemType[STACK_INIT_SIZE+STACK_INCREMENT_SIZE];
if(!S.base) return -1;//堆区分配失败
S.top=S.base+S.size;
S.size+=STACK_INCREMENT_SIZE;
}
*S.top++ = e;//指针运算符优先级低于自增运算符
return 1;
}
int Pop(SqStack &S,ElemType &e)
{
if(S.base==S.top)return -1;
S.top--;
e=*S.top;//==e=*--S.top;
}
int ClearStack(SqStack &S)
{
S.top=S.base;
return 1;
}
int DestroyStack(SqStack &S)
{
S.top=NULL;
S.size=0;
delete(S.base);
S.base=NULL;
return 1;
}
2,迷宫的算法
PostType NextPos(PostType c, int dir)
{//寻找下一个路径块
PostType direct[5] = {{-1,-1},{0,1}, {1,0}, {0,-1}, {-1,0}}; //{行增量,列增量}
c.x += direct[dir].x;
c.y += direct[dir].y;
return c;
}
int MazePath(int maze[][8],PostType start,PostType end ,int n)
{//迷宫路径,我们规定:0表示不可通过,1表示可通过,2表示已走路径
int ans[8][8]={0};
SqStack S;
InitStack(S);//先构建空栈
//-----设置各种初值-----
PostType curpos = start;
int currstep = 1;//步数,即序号
Block e;
do{
if(maze[curpos.x][curpos.y]==1)
{//可通过
cout<<"当前步数:"<<currstep<<endl;
ans[curpos.x][curpos.y] = currstep;
maze[curpos.x][curpos.y] = 2;//留下能通过足迹,改变maze中的值
e.order = currstep;
e.seat = curpos;
e.direction = 1;//构造要入栈的元素
Push(S,e);//入栈
if(curpos.x==end.x && curpos.y==end.y) {
cout<<"总步数:"<<currstep<<endl;
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
{
if(ans[i][j]!=0)cout<<ans[i][j]<<" ";
else cout<<" ";
}
cout<<endl;
}
return 1;
}
curpos = NextPos(curpos,1);//下一个路径块
currstep++;//步数加1
}//if
else //当前不能通过
{
if(!StackEmpty(S))
{
Pop(S,e);
while(e.direction==4 && !StackEmpty(S))
{
ans[e.seat.x][e.seat.y] = 0;
maze[e.seat.x][e.seat.y] = 0;//,先弹出栈,在改变状态。留下不能通过的足迹,改变maze中的值
Pop(S,e);//只要不能通过,都弹出栈,知道找到一个有“可变向的回头路”为止
--currstep;
}//while
if(e.direction<4)
{//找到一个“可变向的回头路”的点
e.direction++;//探寻下一个方向
Push(S,e);//前面将他弹出栈,现在再将他压入栈
curpos = NextPos(e.seat,e.direction);//下一个路径块
}//if
}//if
}//else
}while(!StackEmpty(S));
return 0;
}
3,main,按照此算法,迷宫必须有边界,否则方向判断时数组地址越界
#include<iostream>
#include"Maze.h"
using namespace std;
int main(void)
{
int maze[8][8]={
{0,0,0,0,0,0,0,0},
{0,1 ,1 ,1 ,1, 1 ,1,0},
{0, 1, 1 ,0 ,0 ,1 ,1,0},
{ 0,0, 1, 0 ,0 ,1, 0,0},
{ 0,1, 1, 1 ,0 ,1 ,0,0},
{0, 1, 1 ,0 ,1, 0 ,0,0},
{ 0,1, 1 ,1, 1 ,1, 1,0},
{0,0,0,0,0,0,0,0}};
PostType start,end;
start.x=start.y=1;
end.x = end.y = 6;
MazePath(maze,start,end,8);
return 0;
}
//=====算法描述=====
/*
do{
if(当前块可通过)
{
入栈,步数+1,记录路径
if(当前块为结束块) 找到路径,结束
下一块为当前块的东临
}
else
{//不能通过不入栈
if(栈不为空)
{
将最后一个可通过的块从站里取出
while(该块四周都检查完了,或者栈为空)
一直弹出不能通过的块,设置不能通过标志,记录路径
if(该块四周没检查完)
检查其他方向,
入栈,表示该块还是可通过的
}
}
}while(栈不为空)
*/