广度优先遍历（图和二叉树的层序遍历相关问题）

weixin_46213145

已于 2022-07-22 16:55:59 修改

阅读量741

点赞数

文章标签：宽度优先算法 c++ 广度优先

于 2022-07-19 21:25:18 首次发布

本文链接：https://blog.csdn.net/weixin_46213145/article/details/125876333

版权

本文介绍了使用广度优先遍历（BFS）解决一系列问题，包括腐烂的橘子扩散、岛屿的周长计算、岛屿数量统计、岛屿的最大面积求解、图像渲染算法、边界着色、被围绕区域的处理，以及二叉树的各种层序遍历问题，如层序遍历、自底向上层序遍历、锯齿形层序遍历等。通过对这些问题的探讨，深入理解BFS在图论和二叉树操作中的应用。

摘要由CSDN通过智能技术生成

116. 填充每个节点的下一个右侧节点指针

117. 填充每个节点的下一个右侧节点指针 II

199. 二叉树的右视图

994. 腐烂的橘子

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子周围 4 个方向上相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

class Solution {
    private:
    int dx[4]={-1,1,0,0};
    int dy[4]={0,0,-1,1};
public:
    int orangesRotting(vector<vector<int>>& grid) {
    int res=0;
    queue<pair<int,int>> q;

    int m=grid.size();
    int n=grid[0].size();
    vector<vector<int>> visited(m,vector<int>(n,0));
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(grid[i][j]==2)
            q.push({i,j});
        }
    }
    while(!q.empty()){
        int x=q.front().first;
        int y=q.front().second;
        q.pop();
        for(int i=0;i<4;i++ ){
            int xnew=x+dx[i];
            int ynew=y+dy[i];
            if(xnew>=0&&xnew<m&&ynew>=0&&ynew<n&&grid[xnew][ynew]==1){//下一个遍历的位置在网格内 并且是完好的橘子
                grid[xnew][ynew]=2;//腐烂操作
                visited[xnew][ynew]=visited[x][y]+1;//用visit数组来记录遍历的每一层时候的数值
                //刚开始的时候 是0 相当于不需要感染就已经腐烂 在往后遍历的时候 每一层相应的时间加1
                res=res>visited[xnew][ynew]?res:visited[xnew][ynew];//记录所有visit中的最大值就是最短腐烂所需要的时间
                q.push({xnew,ynew});
            }
        }
    }
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(grid[i][j]==1)
            return -1;
        }
    }//如果进行广度优先遍历之后 还有完好的橘子 那么腐烂失败 返回-1
     return res;
    }
};

463. 岛屿的周长

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

class Solution {
    constexpr static int dx[4] = {0, 1, 0, -1};
    constexpr static int dy[4] = {1, 0, -1, 0};
public:
    int islandPerimeter(vector<vector<int>> &grid) {
        int n = grid.size(), m = grid[0].size();
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j]) {
                    int cnt = 0;
                    for (int k = 0; k < 4; ++k) {
                        int tx = i + dx[k];
                        int ty = j + dy[k];
                        if (tx < 0 || tx >= n || ty < 0 || ty >= m || !grid[tx][ty]) {
                            cnt += 1;//遇到边界或者遇到水就对边长进行加1 因为边长跟边界和水交界的地方才会有边
                        }
                    }
                    ans += cnt;
                }
            }
        }
        return ans;
    }
};

200. 岛屿数量

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

class Solution {
public:
    void dfs(vector<vector<char>>& grid,int x,int y){
        if(grid.size()==0) return ;
        int m=grid.size();
        int n=grid[0].size();
        grid[x][y]='0';
        if(x-1>=0&&grid[x-1][y]=='1') dfs(grid,x-1,y);//下一个需要遍历的位置负荷要求 并且是岛屿1 这个地方x-1必须卸载前面，因为如果超过数组边界 那么grid[x-1][y]就会出错
        if(x+1<m&&grid[x+1][y]=='1') dfs(grid,x+1,y);
        if(y-1>=0&&grid[x][y-1]=='1') dfs(grid,x,y-1);
        if(y+1<n&&grid[x][y+1]=='1') dfs(grid,x,y+1);
    }
    int numIslands(vector<vector<char>>& grid) {
        if(grid.size()==0) return 0;
        int res=0;
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[0].size();j++){
                if(grid[i][j]=='1'){
                    res++;
                    dfs(grid,i,j);//遇到1 那么对1所有相连的1进行广度优先搜索 让1全部变成0 就找到了一个岛屿res++ 再对剩下的1进行遍历
                }
            }
        }
        return res;
    }
};

695. 岛屿的最大面积

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直的四个方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

class Solution {
public:
    int dfs(vector<vector<int>>& image,int x,int y){//返回值需要设置成int 对每一个1进行广搜 搜到一个就加1 最后返回这个1 所相邻的岛屿的面积的大小
        int ans=1;//如果是1 那么本身是算在面积里面的 所以初始化需要设置为1
        
        int m=image.size();
        int n=image[0].size();

        image[x][y]=0;//遍历之后需要将1变为0 防止后续重复遍历

        if(x-1>=0&&image[x-1][y]==1) ans+=dfs(image,x-1,y);