广度优先（BFS）

---

层层递进——广度优先搜索

接上文的迷宫问题，仍然用二维数组存储这个迷宫。小哼在迷宫入口（1,1）处，那么他下一步应该往右边或者下边走。如果用DFS的方式，先让他往一边走，一直走到走不下去为止，然后再尝试另外一种路线。那么，BFS的方法就是一层一层扩展，来找到小哈的位置。具体如下：
最开始小哼在（1,1）处，那么他往下走的可能是（2,1）或（1,2）。这两个点没有找到小哈，只能继续往下走，假如走到（1,2），那么从（1,2）开始，能够走到的点是（3,1）或者（2,2），同时（2,2）这个点又能通过（2,1）走到，所以用一个数组标记已经走过的点。此时，小哼两步能够到达的点都找到了。继续往下走，（2,2）可以到（2,3）和（3,2），（3,1）可以到（3,2）和（4，1）。仍然没有找到小哈的位置，继续重复之前的过程，直到找到小哈位置。

先用结构体定义队列

struct note
{
	int x;//横坐标
	int y;//纵坐标
	int s;//步数
};
struct note que[2501];//地图大小不超过50*50，因此队列扩展不会超过2500
int head, tail;
int a[51][51] = { 0 };//用来储存地图
int book[51][51] = { 0 };//数组book的作用是记录哪些点已经在队列中了，防止一个点被重复扩展，并全部初始化为0
//最开始的时候需要进行队列初始化，即将队列设置为空
head = 1;
tail = 1;
//把(1,1)放入队列，并标记(1,1)已经走过
que[tail].x = 1;
que[tail].y = 1;
que[tail].s = 0;
tail++;
book[1][1] = 1;

然后从（1,1）开始，先尝试往右走到达（1,2）

tx = que[head].x;
ty = que[head].y+1;

判断（1,2）是否越界

if (tx < 1 || tx > n || ty < 1 || ty > m)
    continue;

再判断（1,2）是否为障碍物或者已经在路径中

if(a[tx][ty] == 0 && book[tx][ty] == 0)
{

}

如果满足上面的条件，将（1,2）入队，并标记该点已经走过

//标记该点已经走过
book[tx][ty] = 1;//因为只入队一次，所以不需要将book还原
//插入新的队列
que[tail].x = tx;
que[tail].y = ty;
que[tail].s = que[head].s + 1;//步数+1
tail++;

我们继续尝试往其他方向走，还是按顺时针，从（1,1）可以到达（2,1）需要将（2,1）加入队列。对（1,1）扩展完之后，把（1,1）出队

head++;

完整代码

#include<stdio.h>
struct note
{
	int x;//横坐标
	int y;//纵坐标
	int s;//步数
};
int main()
{
	struct note que[2501];//地图大小不超过50*50，因此队列扩展不会超过2500
	int a[51][51] = { 0 };//用来储存地图
	int book[51][51] = { 0 };//数组book的作用是记录哪些点已经在队列中了，防止一个点被重复扩展，并全部初始化为0
	//定义一个用于表示走方向的数组
	int next[4][2] = { {0,1},//往右走
					  {1,0},//往下走
					  {0,-1},//往左走
					  {-1,0}};//往上走
	int head, tail;
	int i, j, k, n, m, startx, starty, p, q, tx, ty, flag;

	scanf_s("%d %d", &n, &m);
	for (i = 1; i <= n; i++)
		for (j = 1; j <= m; j++)
			scanf_s("%d", &a[i][j]);
	scanf_s("%d %d %d %d", &startx, &starty, &p, &q);
	//最开始的时候需要进行队列初始化，即将队列设置为空
	head = 1;
	tail = 1;
	//把(1,1)放入队列，并标记(1,1)已经走过
	que[tail].x = startx;
	que[tail].y = starty;
	que[tail].s = 0;
	tail++;
	book[startx][starty] = 1;

	flag = 0;//用来标记是否到达目标点，是就是1，不是就是0
	//当队列不空的时候循环
	while (head < tail)
	{
		//枚举四个方向
		for (k = 0; k <= 3; k++) {
			//计算下一个点的坐标
			tx = que[head].x + next[k][0];
			ty = que[head].y + next[k][1];
			//判断是否越界
			if (tx<1 || tx>n || ty<1 || ty>m)
				continue;
			//判断是否为障碍物或者已经在路径上
			if (a[tx][ty] == 0 && book[tx][ty] == 0)
			{
				book[tx][ty] = 1;//因为只入队一次，所以不需要将book还原
				 //插入新的队列
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].s = que[head].s + 1;//步数+1
				tail++;
			}
			//如果到达目标点了，停止扩展，任务结束，推出循环
			if (tx == p && ty == q)
			{
				flag = 1;
				break;
			}
		}
		if (flag == 1)
			break;
		head++;//只有head++才能对后面的点进行扩展
	}
			printf("%d", que[tail - 1].s);

		getchar();
		getchar();
		return 0;
}

---

总结

深度优先是一条路走到黑，走不通了，再回到起点走新的一条路。而广度优先是同时考虑所有可能的情况，我都走，那条最好我走哪条，边走边排除。