数据结构——迷宫问题

#include  
#include 
#include   
#include“string.h“
#define MAX_SIZE 10 //迷规模 
#define TRUE  1 
#define FALSE  0 
#define PASS  0 //通路 
#define WALL  1 //障碍 
#define IN   2 //入口 
#define OUT   3 //出口 
#define WAY   4 //路径 
int GQ=1;
typedef struct POINT 
{  
 int xy;    //该点的坐标 
 int flag;    //方向标记位 
}POINT;  
typedef struct MAZE 
{  int maze[MAX_SIZE][MAX_SIZE]; //迷宫的各点的状态 
   int xy;      //迷宫的行、列数 
   int in_xin_y;     //迷宫入口坐标 
   int out_xout_y;    //迷宫出口坐标 
}MAZE;  
typedef struct STACK {  
   POINT road;      //存放路径信息 
   struct STACK *next;    //下一个路径 
}STACK; //链栈形式 
 
int Meun（void）; 
MAZE *CreateMaze（void）; void Show（MAZE *）; 
void WriteFile（MAZE *char *）; 
MAZE *ReadFile（char *）; 
void Quit（void）; 
void FindWay（MAZE *）; 
STACK *InitStack（void）; 
MAZE *Push（STACK *POINTMAZE *）; 
MAZE *Pop（STACK *MAZE *）; 
int IsEmpty（STACK *）; 
POINT GetTop（STACK）;  
main（） {  
    MAZE *G;
    int choose;
    char fname[10];  
    choose = Meun（）;
    char tt;
    system（“cls“）;
    switch（choose）
      {  
      case 1:
      printf（“\n您有inA、inB、inC、inD四个迷宫选择，请输入你选择的迷宫：“）;     
      scanf（“%s“&fname）;
      G = ReadFile（fname）;
      printf（“文件中的迷宫如下：\n“）;
      Show（G）;
      printf（“入口为：（%d，%d）\n出口为：（%d，%d）\n“G->in_xG->in_yG->out_xG->out_y）;
       break;      
      case 2:exit（0）; 
     default:printf（“\n输入的选项有误！\n“）;       
     exit（0）;  }  
     printf（“\n按任意键查看结果“）;  
     getch（）;  
     system（“cls“）;  
     FindWay（G）;  
     free（G）;  
     printf（“\n按任意键继续“）;  
     getch（）;  
     system（“cls“）;  
     Quit（）; }  
//取栈顶 
POINT GetTop（STACK s） {  
  POINT q;  
 q.x = q.y = -1;  
 q.flag = 0;  
 q = s.next->road;  
 return q; }  
//判空 
int IsEmpty（STACK *s） {  
if （s->next == NULL）   return TRUE;
  return FALSE; }  
//出栈操作 
MAZE *Pop（STACK *sMAZE *G） {  STACK *t;  
 t = s->next;   //在出栈的同时让该点的状态回归PASS  
 s->next = t->next;  
 G->maze[t->road.x][t->road.y] = PASS;  
 free（t）;  
 return G; }  
//入栈操作 
MAZE *Push（STACK *sPOINT pMAZE *G）
{  STACK *t;  
 t = （STACK *）malloc（sizeof（STACK））;  
 t->road = p;  
 t->next = s->next;  //在入栈的同时让该点的状态变为WAY  
 s->next = t;  
 G->maze[p.x][p.y] = WAY;  
 return G; }  
//栈的初始化 
STACK *InitStack（void） {  
 STACK *s;  
 s = （STACK *）malloc（sizeof（STACK））;  
 s->next = NULL;  return s; }  
//找出路 
void FindWay（MAZE *G） {  
 STACK *stack;  POINT p;  
 stack = InitStack（）;  
 p.x = G->in_x;  //将入口坐标入栈 
 p.y = G->in_y;  
 p.flag = 0;  
 G = Push（stackpG）;  
 do  {  
  switch（p.flag）   
    {   case 0:
             if （p.y+1 >= 0  &&  p.y+1 < G->y  &&  G->maze[p.x][p.y+1] == PASS）       
               {        
	         stack->next->road.flag++;        
	         p.y = p.y + 1;        
	         p.flag = 0;       
	         G = Push（stackpG）;  //尝试向当前坐标的右边走 
                   break;       
       }       else stack->next->road.flag++;