一，广度优先遍历

广度优先遍历的算法实现是相对比较简单的，首先我们能知道他的遍历思路，广度优先的遍历思路是一群老鼠的思想，从一个点开始用很多的老鼠，这些老鼠很懒，每天每只老鼠都只会走一步，当然在我们在模拟这个出入的时候，使用队列来进行模拟，这种模拟实际上就是队列的出入栈的操作。

广度优先遍历是没有重复的操作的，每个点最多就会被遍历到一次，遍历模拟的方式就是把每次遍历得到的下层结点都存储到一个队列中，这个队列会只有完成上一层的操作才会进行下一层的递归操作。

二，广度优先遍历的思路和代码实现

1，广度优先遍历的思路

广度优先遍历就是一种队列的思想，在广度优先遍历中是没有嵌套存在的，一般来说广度优先遍历中都是有初始点的 ，并且在广度优先遍历中 我们一般需要对第一组的数据进行处理，保证队列第一点某些值和参数能入队。

	queue <pair<int,int> > q ;
	//1.create queue ;
	d[0][0] = 0 ;
	q.push({
    
    0,0});
	//2.finish queue 参数 ,这里是位置距离参数 

然后就是判断队列中是否有值进行一个递归的操作， 当这个队列中还有值的时候我们取队列中的的第一个值来寻找他的下层，我们要判断这个下层是否符合取值条件，当能完成取的时候我们再进行赋值操作。

1，队列不为空
2，取队头，弹队头 <> 对下面的元素进行判断，判断这个元素能否取
3，对能取的元素进行参数处理，入栈

if(q.size())
		//1.判断队列是否不为空
	{
    
    
		auto t = q.front() ;
		q.pop() ;
		//2.下一层判定 —— 取队列（记得弹出）
		for(int i = 0 ; i < 4 ; i ++ )
		{
    
    
			int x = t.first+ dx[i] ;
			int y = t.second + dy[i] ;
			//2. 下一层判定 —— 取可能的下一层的值，并且进行判断
			if(x >= 0 && y >= 0 && y < m && x < n && d[x][y] == - 1 )
			{
    
    
				//3.下一层判定 —— 对参数进行处理
				d[x][y] = d[t.first][t.second] + 1 ;
				q.push({
    
    x,y}) ;
			}
		}
	}

2,广度优先遍历的代码

#include <iostream>
#include <queue>
#include <algorithm>

using namespace std ;
const int N = 110 ;
int n , m ;

int g[N][N] ;
int d[N][N] ;
 

int bfs()
{
    
    

	queue <pair<int,int> > q ;
	//1.create queue ;
	d[0][0] = 0 ;
	q.push({
    
    0,0});
	//2.finish queue 参数 

	int dx[4] = {
    
    0 , 1 , 0 , - 1 };
	int dy[4] = {
    
    1 , 0 , -1,   0 };

	if(q.size())
		//1.判断队列是否不为空
	{
    
    
		auto t = q.front() ;
		q.pop() ;
		//2.下一层判定 —— 取队列（记得弹出）
		for(int i = 0 ; i < 4 ; i ++ )
		{
    
    
			int x = t.first+ dx[i] ;
			int y = t.second + dy[i] ;
			//2. 下一层判定 —— 取可能的下一层的值，并且进行判断
			if(x >= 0 && y >= 0 && y < m && x < n && d[x][y] == - 1 )
			{
    
    
				//3.下一层判定 —— 对参数进行处理
				d[x][y] = d[t.first][t.second] + 1 ;
				q.push({
    
    x,y}) ;
			}
		}
	}
	return d[n - 1][m - 1] ;
}

int main () 
{
    
    
	
	cin >>  n >> m ;
	for(int i = 0 ; i < n ; i ++ )
		for(int j = 0 ; j < m ; j ++ )
			cin >> g[i][j] ,d[i][j] = - 1;
	cout << bfs() << endl ;
	return 0 ;
}

三，广度优先遍历的模板

广度优先遍历的主要的思想就是一个队列的处理，队列的处理就是 BFS 的一个核心操作，

首先我们应该先创建一个队列，完成第一个点的值的压入和参数的赋值

当队列内还有参数的时候我们进行循环操作，找到他所有可能的点
1，先取队头
2，对对头进行取点操作
3，判断是不是合理的

完成赋值操作

#include <iostream>
#include <queue>
using namespace std ;

void bfs ()
{
    
    
	queue <int>  q;
	q.push() ;
	参数赋值
	// 完成队列的创建 ， 队列第一个值的赋值操作
	while (q.size() )
	{
    
    
		int t = q.front() ;
		//取队头 
		for( 向下的递归)
		{
    
    
		if(判断能不能取)
		{
    
    
			//参数赋值，压入操作
		}
		}
	}

}


int main ()
{
    
    
	return 0 ;
}