算法描述

用一个队列q来存储记录走过的坐标
在这里插入图片描述
经过多次记录后：
对应的迷宫路径示意图如下：

则读出来的迷宫路径坐标如下：

我们开始敲代码吧：

代码部分

准备工作：

1. 建立迷宫

	**//对应的数组下标 0 1 2 3 4 5 6 7 8 9**
	int a[][10]={	1,1,1,1,1,1,1,1,1,1,
					1,-1,1,0,0,0,1,1,1,1,//起点为-1 
					1,0,0,0,0,0,1,0,0,1,
					1,0,1,0,0,0,1,0,0,1,
					1,0,1,1,1,1,0,0,1,1,
					1,0,0,0,0,1,0,0,1,1,
					1,0,1,1,0,0,0,1,1,1,
					1,0,0,0,0,1,0,0,0,1,
					1,1,1,1,1,1,1,0,0,1,
					1,1,1,1,1,1,1,1,1,1};

2. 建立顺序队列等

#define Maxze 50 
typedef struct	//对应一个坐标
{
	int hang;	//第几行
	int lie;	//第几列
	int qian;	//由第几个坐标得来的
}ElemType;
 
typedef struct
{
	ElemType data[Maxze];		//用来记录坐标的数组
	int front,rear;				//队列的两个指针
}SqQueue;

重点部分

3. 开始建立队列的基本操作

//1.初始化队列
void IniterQueue(SqQueue *&q)
{
	q=new SqQueue;
	q->front=-1;
	q->rear=-1;
} 

//2.销毁队列
void DestroyQueue(SqQueue *&q)
{
	delete q;
}

//3.判断是否空队列 
bool QueueEmpty(SqQueue *q) 
{
	if(q->front==q->rear)
		return true;
	else 
		return false;
}

//4.判断是否满队列
bool QueueFull(SqQueue *q)
{
	if(q->rear==Maxze-1)
		return true;
	else 
		return false;
} 

//5.入队
bool enQueue(SqQueue *&q,ElemType e)
{
	if(q->rear==Maxze-1)		//队满上溢出
		return false;
	q->rear++;
	q->data[q->rear]=e;
		return true;
}

//6.出队
bool deQueue(SqQueue *&q,ElemType &e)
{
	if(q->front==q->rear)		//队空下溢出
		return false;
	q->front++;
	e=q->data[q->front];
		return true;
}

4. 迷宫内的操作

//7.终点回溯起点 
void Huishuo(SqQueue *&q,int e)//输出迷宫所有坐标（1：障碍，0：可走
{
	a[8][8]=-2;					//-1：MIgongQueue函数途径坐标，-2：起点到终点的路线 
	int eh=8,el=8;
	while(eh!=1||el!=1)
	{
		eh=q->data[e].hang;
		el=q->data[e].lie;			//用eh,el截取坐标 
		e=q->data[e].qian;			// e等于该坐标的上一个路线对应坐标 
		a[eh][el]=-2;
	}
} 
//8.起点找到终点 
bool MigongQueue(SqQueue *&q)
{
	int eh,el,eq;
	ElemType e;
	e.hang=1,e.lie=1,e.qian=-1;		//将迷宫起点入队 
	enQueue(q,e);
	while(!QueueFull(q))
	{
		deQueue(q,e);
		eh=e.hang,el=e.lie,eq=q->front;
		if(a[eh-1][el]==0) 				//将其附近可走的点进队 
		{
			e.hang=eh-1;	e.lie=el;	e.qian=eq;
			enQueue(q,e);
			a[e.hang][e.lie]=-1; 
			if(e.hang==8&&e.lie==8) 		//当到达终点时回溯到起点，并结束 
			{
				Huishuo(q,eq);
				return true;
			}
		}
		if(a[eh][el+1]==0) 
		{
			e.hang=eh;	e.lie=el+1;		e.qian=eq;
			enQueue(q,e);
			a[e.hang][e.lie]=-1; 
			if(e.hang==8&&e.lie==8) 		//当到达终点时回溯到起点，并结束
			{
				Huishuo(q,eq);
				return true;
			}
		}
		if(a[eh+1][el]==0) 
		{
			e.hang=eh+1;	e.lie=el;	e.qian=eq;
			enQueue(q,e);
			a[e.hang][e.lie]=-1;
			if(e.hang==8&&e.lie==8) 		//当到达终点时回溯到起点，并结束
			{
				Huishuo(q,eq);
				return true;
			} 
		}
		if(a[eh][el-1]==0) 
		{
			e.hang=eh;     e.lie=el-1;		e.qian=eq;
			enQueue(q,e);
			a[e.hang][e.lie]=-1; 
			if(e.hang==8&&e.lie==8) 		//当到达终点时回溯到起点，并结束
			{
				Huishuo(q,eq);
				return true;
			}
		}
	}
	return false; 
}

5. 输出迷宫

//9.输出迷宫
void DispQueue() 
{
	int i=0,j=0;
	for(i=0;i<10;++i)	//可选择输出整个迷宫图样或输出所有路线坐标 
	{
		for(j=0;j<10;j++)//输出迷宫所有坐标（1：障碍，0：可走， 
		{	
			if(a[i][j]==-2) 
			{
				cout<<"  1  ";		//-1：MIgongQueue函数途径坐标，-2：起点到终点的路线） 
				//cout<<a[i][j]<<"    ";
			} 
			else if(a[i][j]==0||a[i][j]==-1) cout<<"  0  ";
			else cout<<"  *  ";
		}
		cout<<endl<<endl;
	}
}

结尾部分

6. 主函数操作

int main()
{
	cout<<"迷宫的样式：\n";
	DispQueue();
	
	SqQueue *q;
	IniterQueue(q);		//建立队列，执行迷宫函数 
	MigongQueue(q);
	
	cout<<"迷宫的路线\n";
	DispQueue();
	
	DestroyQueue(q);
}