---

前言

在这篇文章之前，已对非线性结构遍历的另一种方法——深度优先遍历进行了讲解，其中很多概念词都是共用的。为了更好的阅读体验，最好先在掌握或起码了解dfs的基础上，再来阅读本文章，否则因为会有很多概念词看不明白而降低阅读体验。

一命通关深度优先遍历-CSDN博客https://blog.csdn.net/qq_74260823/article/details/136819359?spm=1001.2014.3001.5501

---

广度优先遍历

简介

与dfs不同，bfs是先遍历完一层的所有结点，再往下一层进发。bfs先踏完第一步能到达的所有结点，然后再遍历第二步才可以到达的结点，一直遍历到最远才可以到达的结点，完成遍历。

• 但是，同一个结点可能会在两个范围中：

•  也可能会有回头路：

不过，所有的结点只能被遍历一次，所以，大部分bfs问题，都需要配有一个标记数组。

实现方法

我们想知道第二步才可以到达的结点，最直接的想法就是在找到所有第一步就能到达的情况下，再走一步，就是第二步才可以到达的结点。为了实现这个思想，即通过上一层去找下一层的结点，最直接的实现方法就是采用两个数组：

我们遍历上层数组的所有元素，然后通过这些元素找到他们相邻的结点，就是下一层元素的所有元素。
然后，继续往下遍历，将上层数组清空，与下层数组交换，如此反复交替，一直到走到最后一层。

不过，这种方法可以优化成一个队列实现： 

将上一层的元素弹出的同时，将下一层的元素带入队列尾，这种方法思想在二叉树的层序遍历中已经详细讲过了，就不再重复说明了。

因为解题思路和公式非常非常套路化，所以直接上题目：

200. 岛屿数量 - 力扣（LeetCode）

简单翻译一下题目，就是找到有几个不挨着的1区块。
而解法也很简单，我们遍历所有元素，当遇到1时，就采用bfs或者dfs将相邻的1全部标记一下，我们这里用bfs来实现。

首先还是在dfs里一模一样的：

1. 位移数组drow和dcol
2. 主函数部分，遍历每个源头
3. 判断边界条件

而唯一和dfs不一样的，也只不过是dfs和bfs函数中的一小部分

class Solution {
    int m,n;
    vector<vector<bool>> record;
    int drow[4]={1,-1,0,0};
    int dcol[4]={0,0,1,-1};
    int ret;//与dfs一模一样
    typedef pair<int,int> ii;
public:
    void bfs(vector<vector<char>>& grid,int i,int j)
    {
        queue<ii> que;
        que.push({i,j});
        record[i][j]=true;

        while(!que.empty())
        {
            auto [row,col]=que.front();que.pop();
            for(int i=0;i<4;i++)
            {
                int newrow=row+drow[i];
                int newcol=col+dcol[i];
                if(newrow>=0&&newrow<m&&newcol>=0&&newcol<n&&
                record[newrow][newcol]==false&&grid[newrow][newcol]=='1')//与dfs一模一样
                {
                    que.push({newrow,newcol});
                    record[newrow][newcol]=true;
                }
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        m=grid.size();
        n=grid[0].size();
        record.resize(m,vector<bool>(n));

        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(record[i][j]==false&&grid[i][j]=='1')
                {
                    bfs(grid,i,j);
                    ret++;
                }
            }
        }

        return ret;
    }//整个主函数也与dfs一模一样
};

所以，bfs的公式也很明了，和dfs大差不差：

公式

class Solution {
    int dx[4] = { 0,0,1,-1 };
    int dy[4] = { 1,-1,0,0 };//方向数组
    vector<vector<bool>> record;//标记数组
    int m, n;//矩阵长宽
    typedef pair<int, int> ii;
public:
    void bfs(vector<vector<int>>& grid, int i, int j)
    {
        queue<ii> que;//创建bfs用的队列
        que.push({ i , j });//将源头插入队列中

        while (!que.empty())
        {
            auto [row, col] = que.front();//取队头元素

            for (int i = 0; i < 4; i++)
            {
                int nextrow = row + dy[i];
                int nextcol = col + dx[i];//新的坐标
                if (nextrow >= 0 && nextrow < m && nextcol >= 0 && nextcol < n//不越界
                    && record[nextrow][nextcol] == false//没有走回头路
                    && grid[nextrow][nextcol]...)//满足题目要求
                {
                    record[nextrow][nextcol] = true;
                    que.push({ nextrow,nextcol });
                }
            }
        }

    }
    ... main(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();
        record.resize(m, vector<bool>(n));

        //遍历每一个源头
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (record[i][j]==false&&grid[i][j] != 0)
                {
                    record[i][j] = true;
                    bfs(grid, i, j);
                }
            }
        }
    }
};

---