广度优先搜索（BFS)应用——层序遍历和最段路径
BFS模板：
BFS使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS总共有两个模板：
模板1：如果不需要确定当前遍历到了哪一层，BFS模板如下。
1 while queue 不空： 2 cur = queue.pop() // 弹出队列的头部元素当做当前遍历点 3 for 节点 in cur的所有相邻节点： 4 if 该节点有效且未访问过： 5 queue.push(该节点)
模板2：如果要确定当前遍历到了哪一层，BFS模板如下。
这里增加了level表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。size表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。
level = 0
while queue 不空：
{
size = queue.size() // size表示即将要遍历的那一层的元素个数。
while (size --) // 当size减到0时，代表这一层遍历完了
{
cur = queue.pop()
for 节点 in cur的所有相邻节点：
if 该节点有效且未被访问过：
queue.push(该节点)
}
level ++;
}
上面两个是通用模板，在任何题目中都可以用，是要记住的！
应用一：层序遍历
LeetCode 102. Binary Tree Level Order Traversal 二叉树的层序遍历（Medium）
本题要求二叉树的层次遍历，所以同一层的节点应该放在一起，故使用模板二。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root:
return []
res = []
q = [root]
while q:
temp = []
for i in range(len(q)): # 每一次循环输出一层
r = q.pop(0)
temp.append(r.val)
if r.left:
q.append(r.left)
if r.right:
q.append(r.right)
res.append(temp) # 记录temp(一层的数据）
return res
C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
queue<TreeNode*> que;
que.push(root);
if (root ==nullptr) {
return res;
}
while (!que.empty()) {
int size = que.size();
vector<int> temp;
while (size--) {
TreeNode* cur = que.front();
que.pop();
temp.push_back(cur->val);
if (cur->left) {
que.push(cur->left);
}
if (cur->right) {
que.push(cur->right);
}
}
// 遍历完一层了
res.push_back(temp);
}
return res;
}
};
应用二：最短路径
在一棵树中，一个结点到另一个结点的路径是唯一的，但在图中，结点之间可能有多条路径，其中哪条路最近呢？这一类问题称为最短路径问题。最短路径问题也是 BFS 的典型应用，而且其方法与层序遍历关系密切。
（1）树结构
Leetcode 111. 二叉树的最小深度
在二叉树中，BFS 可以实现一层一层的遍历。在图中同样如此。从源点出发，BFS 首先遍历到第一层结点，到源点的距离为 1，然后遍历到第二层结点，到源点的距离为 2…… 可以看到，用 BFS 的话，距离源点更近的点会先被遍历到，这样就能找到到某个点的最短路径了。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == nullptr) return 0;
queue<pair<TreeNode*, int>> que; // pair 记录 当前节点及深度
que.emplace(root, 1); // 用que.push会出现语法错误
while (!que.empty())
{
TreeNode* node = que.front().first;
int depth = que.front().second;
que.pop();
if (node->left == nullptr && node->right == nullptr)
{
return depth;
}
if (node->left != nullptr)
{
que.emplace(node->left, depth + 1);
}
if (node->right != nullptr)
{
que.emplace(node->right, depth + 1);
}
}
return 0;
}
};
（2）图结构
参考文章：https://www.cnblogs.com/sbb-first-blog/p/13259728.html
