数据结构（C++) 栈-迷宫问题

/*本函数二维坐标从0开始*/
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define INFEASIBLE -2
#define COL 10
#define ROW 10

typedef struct
{
int row;
int col;
}POS;

typedef struct
{
POS pos;
int come;
int leave;
}Maze;

typedef struct
{
Maze *base;
Maze *top;
int stacksize;
}SqStack;

void SqStack_Init(SqStack &S)
{
S.base=(Maze *)malloc(STACK_INIT_SIZE*sizeof(Maze));//申请空间并判断是否成功
if(!S.base)
exit(INFEASIBLE);
S.top=S.base;//设置为空栈
S.stacksize=STACK_INIT_SIZE;//设置栈的大小
}//初始化栈

void SqStack_Push(SqStack &S,Maze Elem)
{
if(S.top-S.base>=S.stacksize)//判断时候超过当前的栈的大小
{
S.base=(Maze *)realloc(S.base,(STACK_INIT_SIZE+STACKINCREMENT)*sizeof(Maze));//重新申请空间并判断是否成功
if(!S.base)
exit(INFEASIBLE);
S.top=S.base+S.stacksize;//更改栈顶地址
S.stacksize+=STACKINCREMENT;//更改栈的大小
}
*S.top++=Elem;//赋值入栈
}//入栈

int SqStack_Pop(SqStack &S,Maze &Elem)
{
if(S.base==S.top)//判断是否为空栈
return ERROR;
Elem=*--S.top;//赋值返回
return OK;
}//出栈

int SqStack_Gettop(SqStack &S,Maze &Elem)
{
if(S.base==S.top)//判断是否为空栈
return ERROR;
Elem=*(S.top-1);//赋值返回
return OK;
}

int SqStack_Show(SqStack &S)
{
Maze *Base=S.base;//把栈底地址赋值给另外一个地址
if(S.base==S.top)//判断是否为空栈
return ERROR;
while(Base!=S.top)//当地址等于栈顶地址时结束遍历
{
printf("(%d,%d)->",Base->pos.row,Base->pos.col);//输出
Base++;//地址移位
}
printf("\b\b   \n");
return OK;
}//输出栈

int Maze_Arr_i(int Maze_Arr[][10],Maze cur,int i)
{
switch(i)//返回对应方向的迷宫值
{
case 1:
return Maze_Arr[cur.pos.row][cur.pos.col+1];
break;
case 2:
return Maze_Arr[cur.pos.row+1][cur.pos.col];
break;
case 3:
return Maze_Arr[cur.pos.row][cur.pos.col-1];
break;
case 4:
return Maze_Arr[cur.pos.row-1][cur.pos.col];
break;
}
}//cur的i方位的地址的值

int Next_come(int leave)
{
switch(leave)
{
case 1:
return 3;
break;
case 2:
return 4;
break;
case 3:
return 1;
break;
case 4:
return 2;
break;
}
}//next位置的来向come由cur的去向leave决定

void Next_pos(Maze cur,Maze &next)
{
switch(next.come)
{
case 1:
next.pos.row=cur.pos.row;
next.pos.col=cur.pos.col-1;
break;
case 2:
next.pos.row=cur.pos.row-1;
next.pos.col=cur.pos.col;
break;
case 3:
next.pos.row=cur.pos.row;
next.pos.col=cur.pos.col+1;
break;
case 4:
next.pos.row=cur.pos.row+1;
next.pos.col=cur.pos.col;
break;
}
}//next的pos由next的come向和cur的pos决定
/*
0表示可走方块，1表示不可走方块
方位示意图：
4
3   *   1
2
走迷宫时，先从1方位开始，依次到4方位
当一个点三个方位都是不可走方块，并且为非终点、非起点时，走过该点时，退出后将该点标1
*/

int Next(int Maze_Arr[][COL],Maze &cur,Maze &next)
{
int i;
if(cur.leave%4+1==cur.come)//判断下一方向是不是最开始来向
{
Maze_Arr[cur.pos.row][cur.pos.col]=1;//修改迷宫
return ERROR;//死路
}
i=cur.leave%4+1;//转换方向
while(Maze_Arr_i(Maze_Arr,cur,i))//判断该方向是否可通
{
i=i%4+1;//转换方向
if(i==cur.come)//判断该方向是不是最开始来向
{
Maze_Arr[cur.pos.row][cur.pos.col]=1;//修改迷宫
return ERROR;//死路
}
}
cur.leave=i;//标记当前去向
next.come=Next_come(cur.leave);//求next来向
Next_pos(cur,next);//求next的坐标
return OK;
}//寻求cur位置的next位置

int SqStack_Search(SqStack &S,Maze next)
{
Maze *Base=S.base;//把栈底地址赋值给另外一个地址
if(S.base==S.top)//判断是否为空栈
return OK;//没出现
while(Base!=S.top)//当地址等于栈顶地址时结束遍历
{
if(Base->pos.row==next.pos.row&&Base->pos.col==next.pos.col)
return ERROR;//曾经经过该点
Base++;//地址移位
}
return OK;

}//查找next位置是否走过

int Maze_Run(int Maze_Arr[][COL],POS begin,POS end)
{
int i=1,State1,State2;
Maze cur,next;
SqStack S;
SqStack_Init(S);//初始化栈
cur.pos.row=begin.row;
cur.pos.col=begin.col;//将当前点设置为起点
cur.come=1;
while(Maze_Arr_i(Maze_Arr,cur,i))
{
i++;
if(i==5)
return ERROR;
}//遍历直至当前点有出口
cur.leave=i;//标记去向
SqStack_Push(S,cur);//将当前点入栈
next.come=Next_come(cur.leave);//求next的来向
Next_pos(cur,next);//求next的坐标
while(1)
{
next.come=Next_come(cur.leave);//求next的来向
next.leave=next.come;//求初始化next的去向
cur=next;//移动位置
if(cur.pos.row==end.row&&cur.pos.col==end.col)//判断是否到达终点
{
SqStack_Push(S,cur);
break;
}
State1=Next(Maze_Arr,cur,next); //求next
State2=SqStack_Search(S,next);//已过路径判断next是否是
while(State1==ERROR||State2==ERROR)
{
State1=SqStack_Pop(S,cur);//出栈
if(State1==ERROR)
return ERROR;
State1=Next(Maze_Arr,cur,next);//求next
State2=SqStack_Search(S,next);//判断next是否为已过路径
}
SqStack_Push(S,cur); //入栈
}
printf("找到路径:\n");
State1=SqStack_Show(S);//输出路径
return OK;
}//走迷宫

int main()
{
//预置迷宫
int Maze_Arr[ROW][COL]={{1,1,1,1,1,1,1,1,1,1},{1,1,1,1,0,0,0,0,0,1},{1,1,0,0,0,1,0,0,0,1},{1,1,0,0,0,1,0,1,0,1},{1,1,0,0,0,1,0,1,0,1},{1,1,1,1,1,0,0,0,0,1},{1,0,0,0,0,0,0,0,0,1},{1,0,1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1}};
int State,i,j;
for(i=0;i<ROW;i++)
{
for(j=0;j<COL;j++)
printf("%d ",Maze_Arr[i][j]);
printf("\n");
}//输出迷宫
POS begin,end;
begin.row=3;
begin.col=3;
end.row=8;
end.col=8;
printf("起点->终点:(%d,%d)->(%d,%d)\n",begin.row,begin.col,end.row,end.col);
/*
printf("请输入迷宫!\n");
for(i=0;i<ROW;i++)
for(j=0;j<COL;j++)
scanf("%d",&Maze_Arr[i][j]);
printf("请输入迷宫起点:");
scanf("%d%d",&begin.row,&begin.col);
printf("请输入迷宫终点:");
scanf("%d%d",&end.row,&end.col);
*/
State=Maze_Run(Maze_Arr,begin,end);
if(State==ERROR)
printf("找不到出路!\n");
return 0;
}