#define MaxSize 100
#include <stdlib.h>
#include<stdio.h>
#include<malloc.h>
typedef struct Elem
{//定义元素数据结构类型
int x;
int y;
}Elem;
typedef struct
{
Elem num[MaxSize];//指针数组
int front;
int rear;
int tag; //front==rear时表示队列满或空的标志：tag==1表示满，tag==0表示空
}LinkQueue;
LinkQueue InitQu(LinkQueue *q)
{
q=(LinkQueue *)malloc(sizeof(LinkQueue));//分配空间
q->front=0;
q->rear=0;
q->tag=0;
//q->num=NULL;
return *q;
}
LinkQueue Delet(LinkQueue *q)
{
q->rear=q->rear-1;
return *q;
}
LinkQueue EnQueue(LinkQueue *q,int i,int j)
{//struct LinkQueue num[MaxSize];
q->num[q->rear].x=i;
q->num[q->rear].y=j;
q->rear=q->rear+1;
return *q;
}
void main()
{LinkQueue Q;
Q=InitQu(&Q);
int a[10][10]=
{{0,0,0,0,0,0,0,0,0,0},//0
{0,1,1,0,1,1,1,0,1,0},//1
{0,1,1,0,1,1,1,0,1,0},//2
{0,1,1,1,0,0,0,1,1,0},//3
{0,1,0,0,0,1,1,1,1,0},//4
{0,1,1,0,0,1,1,1,1,0},//5
{0,1,1,1,1,1,0,1,1,0},//6
{0,1,0,0,0,1,0,0,1,0},//7
{0,0,1,1,1,1,1,1,1,0},//8
{0,0,0,0,0,0,0,0,0,0}};//9
int i=1;
int j=1;
for(;i!=8||j!=8;)
{
if(a[i+1][j]==1)
{
i++;
EnQueue(&Q,i,j);
a[i][j]=2;//标记说明此为可通，且已走过
}
else
{
if(a[i-1][j]==1)
{i–;EnQueue(&Q,i,j);a[i][j]=2;}
else
{
if(a[i][j+1]==1)
{j++;EnQueue(&Q,i,j);a[i][j]=2;}
else
{
if(a[i][j-1]==1)
{j–;EnQueue(&Q,i,j);a[i][j]=2;}
else
{ if(i==1&&j==1)
{
//printf(“ERROR”);
break;
}
else
{
a[i][j]=0;//此路为死路，标记为零
Delet(&Q);//删除当前的节点
//Q.rear=Q.rear-1;//没有–Q.rear之前Q.rear内元素即指向刚刚删除节点的i，j所以“–”；
i=Q.num[Q.rear-1].x;//rear本是指向下一个该填入数值的位置，-1读出上一个数值
j=Q.num[Q.rear-1].y;
// Q.rear=Q.rear+1;//保证Q.rear指向的地址为空，好存入下一个数据时不会把前一个冲掉；
}
}
}
}
}
}
if(i==1&&j==1)
{
printf(“此迷宫不可通“);
}
else
{
printf(“此迷宫可通,迷宫路径为：/n”);
int n=0;
for( n=Q.front;n<Q.rear;n++)
{
printf(“(%d,%d) “,Q.num[n].x,Q.num[n].y);
}
}
}
看似是队列实现，其实根本没有遵守队列的规则，没有实现先进先出的原则，用队列的话应该是从front中读取（x，y）试探性看它的四周是否为通路，如果是同路的话存入队列，当四周都试完后，无论是否为死路，立即从队列front中取出另一元素，随之删除此位置（即front++）。
此处更像是用栈来实现的：即取出一个元素，试探四周，可以的话存入，并在刚存入的元素中取出另一元素，如果四周没路再删除，取最近一个，如此反复。
由此可看出栈实现迷宫问题是深度上的搜索，队列实现迷宫则是广度上的搜索。
//而且if语句用的比较繁琐，向四周搜索也可以用一个循环来完成
