【深度优先遍历】经典岛屿问题汇总

已于 2022-05-13 22:26:48 修改
阅读量1.9k 收藏 30
点赞数 2
分类专栏： 数据结构与算法 文章标签： leetcode 深度优先 算法 图搜索算法 迭代加深
于 2022-05-10 23:22:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41959920/article/details/124699828
版权

提示：如果本文对您有帮助，欢迎点赞支持！

前言

        岛屿系列算法问题是经典的面试高频题，岛屿系列题目的核心考点就是用 DFS/BFS 算法遍历二维数组。如何在二维矩阵中使用 DFS 搜索呢？

        我们可以把二维矩阵中的每个点看做一个节点，这个节点的上下左右四个位置就是相邻节点，那么整个矩阵就可以抽象成一幅网状的「图」结构，二维矩阵的搜索问题就变成了从某个点出发，向上下左右四个方向进行深度搜索的问题，该dfs函数的框架如下：

// 从(i, j)出发，向相邻四个方向搜索
void dfs(vector<vector<int>>& grid,int i,int j, vector<vector<bool>>& visited) {
    int m = grid.length, n = grid[0].length;
    // 如果超出索引边界，返回
    if (i < 0 || j < 0 || i >= m || j >= n) return;
    // 如果已遍历过 (i, j)，返回
    if (visited[i][j]) return;
    // 进入节点 (i, j)
    visited[i][j] = true;// 标记当前点已经访问过
    dfs(grid, i - 1, j, visited); // 向上搜索
    dfs(grid, i + 1, j, visited); // 向下搜索
    dfs(grid, i, j - 1, visited); // 向左搜索
    dfs(grid, i, j + 1, visited); // 向右搜索
}

         该dfs函数有一个 visited 布尔数组的参数，其目的是防止走回头路，在不同的问题中可以灵活变换，这里放入模板是告诉你二维矩阵需要有一个标记来防止走回头路。

   阅读完本文，你将可以提交如下LeetCode题目：

类型LeetCode题目
求岛屿的数量

200. 岛屿数量（中等难度）

1254. 统计封闭岛屿的数目（中等难度）

1905. 统计子岛屿（中等难度）

694. 不同岛屿的数量（中等难度）

求岛屿的周长

463. 岛屿的周长（简单难度）

求岛屿的面积

695. 岛屿的最大面积（中等难度）

剑指 Offer II 105. 岛屿的最大面积（中等难度）

1020. 飞地的数量（中等难度）

求矩阵的最长递增路径

329. 矩阵中的最长递增路径（困难难度）

剑指 Offer II 112. 最长递增路径
在矩阵中匹配字符串

79. 单词搜索（中等难度）

剑指 Offer 12. 矩阵中的路径（中等难度）

一、求岛屿的数量

200. 岛屿数量（中等难度）

输入一个二维网格grid，其中'1'表示陆地，'0'表示水域，整个网格被水完全包围，陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿，如下gird中共有6个岛屿。

 点评：

在下述写法中，dfs 函数遍历到值为 '0' 的位置会直接返回，而且搜索一个岛屿后就不会再遍历该岛屿中的"1"，所以我们可以直接省略visited数组，只要把经过的位置都设置为 '0'，就可以起到不走回头路的作用。

注意该题目中是个字符矩阵。

class Solution {
public:
    /* 深度优先遍历：
    二维遍历每个点，如果当前点是陆地就深度遍历
    每个点都以上下左右的方式去做深度递归，搜索过的方格都需要做标记，
    */
    int m;
    int n;
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(); 
        n = grid[0].size();
        // 遍历二维数组中的每个点
        int res=0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果当前点是陆地，就判断是否形成岛屿（该条件可以删除，但是影响效率）
                if(grid[i][j] == '1'){
                    dfs(grid,i,j);//一定会形成一个岛屿，搜索后就淹没了
                    res++;
                }
            }
        }
        return res;
    }
    // 从[i,j]向四周搜索，将搜索过的1标记为其他值（0,淹没）
    void dfs(vector<vector<char>>& grid,int i,int j){
        // 如果当前点超出范围
        if(i<0||i>=m||j<0||j>=n) return ;
        // 如果当前点是湖水
        if(grid[i][j]=='0') return ;
        // 如果当前点已遍历过
        if(grid[i][j]=='2') return ;
        grid[i][j]='2';// 遍历过就标记为2,只要不标记为1（陆地）就行
        // 向四周遍历
        dfs(grid,i-1,j);// 向左遍历
        dfs(grid,i+1,j);// 向右遍历
        dfs(grid,i,j-1);// 向上遍历
        dfs(grid,i,j+1);// 向下遍历
    }
};

1254. 统计封闭岛屿的数目（中等难度）

输入一个二维网格grid，其中0表示陆地，1表示水域，陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿，封闭岛屿则是其四周完全被水包围，如下gird中共有2个封闭岛屿。

 点评：

该题目中没有假定二维矩阵四周是被海水包围的，所以「靠边的岛屿」理论上可能就不是「封闭岛屿」。

所以在dfs 函数中将「靠边的岛屿」标记下，这样统计的岛屿个数中去除「靠边的岛屿」就是「封闭岛屿」的个数。

class Solution {
public:
    /* 该题用0表示土地，1表示水（和其他岛屿问题不同）
    所有的岛屿可以分为封闭岛屿和非封闭岛屿，我们已知如何求所有岛屿数量（200题）
    封闭岛屿的特点是接触到了边界，所以只要判断当前统计的岛屿是不是封闭岛屿即可
    */
    int m;
    int n;
    int closedIsland(vector<vector<int>>& grid) {
        m = grid.size(); 
        n = grid[0].size();
        // 遍历二维数组中的每个点
        int res=0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果当前点是陆地，就扩散
                if(grid[i][j] == 0){
                    bool isClosed=false;
                    dfs(grid,i,j,isClosed) ;
                    if(!isClosed) res++;
                }
            }
        }
        return res;
    }
    void dfs(vector<vector<int>>& grid,int i,int j,bool& isClosed){
        // 如果当前点超出范围就返回
        if(i<0||i>=m||j<0||j>=n) {
            isClosed=true;
            return ;
        }
        // 如果当前点不是陆地就返回
        if(grid[i][j]==1) return ;
        // 如果当前点遍历过就返回
        if(grid[i][j]==2) return ;
        grid[i][j]=2;// 遍历过就标记为2
        // 向四周遍历
        dfs(grid,i-1,j,isClosed);// 向左遍历
        dfs(grid,i+1,j,isClosed);// 向右遍历
        dfs(grid,i,j-1,isClosed);// 向上遍历
        dfs(grid,i,j+1,isClosed);// 向下遍历
    }
};

1905. 统计子岛屿（中等难度）

输入一个2个二维网格grid1和grid2，其中1表示陆地，0表示水域，陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿，假设整个网格被水完全包围。如果grid2的一个岛屿的每一个格子都被grid1中同一个岛屿完全包含，那么称grid2中的这个岛屿为子岛屿。

 点评：

这道题的关键在于，如何快速判断子岛屿？

什么情况下 grid2 中的一个岛屿 B 是 grid1 中的一个岛屿 A 的子岛？

当岛屿 B 中所有陆地在岛屿 A 中也是陆地的时候，岛屿 B 是岛屿 A 的子岛。

反过来说，如果岛屿 B 中存在一片陆地，在岛屿 A 的对应位置是海水，那么岛屿 B 就不是岛屿 A 的子岛。

那么只要遍历 grid2 中的所有岛屿，把那些不可能是子岛的岛屿排除掉，剩下的就是子岛。

依据这个思路，可以直接写出下面的代码：

class Solution {
public:
    /*当岛屿B中所有陆地在岛屿 A 中也是陆地的时候，岛屿 B 是岛屿 A 的子岛。
    反过来说，如果岛屿 B 中存在一片陆地，在岛屿 A 的对应位置是海水，
    那么岛屿 B就不是岛屿A的子岛*/
    int m;
    int n;
    int countSubIslands(vector<vector<int>>& grid1, vector<vector<int>>& grid2) {
        m = grid1.size(); 
        n = grid1[0].size();
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果岛屿A中陆地在岛屿B中是海水，就淹掉这座小岛
                if(grid1[i][j]==0&&grid2[i][j]==1)
                    dfs(grid2,i,j);//淹掉这座小岛
            }
        }
        // 遍历二维数组中的每个点
        int res=0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果当前点是陆地，就判断
                if(grid2[i][j] == 1){
                    dfs(grid2,i,j);
                    res++;
                }
            }
        }
        return res;
    }
    void dfs(vector<vector<int>>& grid,int i,int j){
        // 如果当前点超出范围
        if(i<0||i>=m||j<0||j>=n) return ;
        // 如果当前点是湖水
        if(grid[i][j]!=1) return ;
        // 如果当前点已遍历过
        if(grid[i][j]==0) return ;
        grid[i][j]=0;// 遍历过就标记为0
        // 向四周遍历
        dfs(grid,i-1,j);// 向左遍历
        dfs(grid,i+1,j);// 向右遍历
        dfs(grid,i,j-1);// 向上遍历
        dfs(grid,i,j+1);// 向下遍历
    }
};

694. 不同岛屿的数量（中等难度）

输入一个二维网格grid，其中1表示陆地，0表示水域，如果陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿。假设岛屿四周被海水包围。问网格中共有多少个形状不同的岛屿。两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。

 点评：

我们已经会统计矩阵中所有岛屿的数量，也会统计其中「封闭岛屿」的数量，该题是求其中「不同岛屿」的数量。那么如何区分「不同岛屿」？

该题目中的意思是两个岛屿的节点的拓扑结构一样就是相同岛屿（可以直接平移得到），否则就是「不同岛屿」。那么如何表示一个岛屿的拓扑结构呢？这和岛屿的遍历顺序有关。

简单点说，从grid[i][j]出发向四周搜索时，不同的结构在不同的时机返回的顺序不一样，有的结构可能向上搜索一次就直接返回，向下搜索多次才能返回。对于形状相同的岛屿，如果从同一起点出发，dfs 函数遍历的顺序肯定是一样的。

我们可以为dfs函数输入一个字符串参数，其每次向四个方向搜索一次就添加一个不同的字符，这样相同结构的岛屿就会得到一条相同的字符串，否则就是不同的字符串。

将每个岛屿搜索后的字符串放入哈希集合中，哈希集合自动帮我们去重，然后返回哈希集合的大小即可。

class Solution {
public:
    int m; // 行数
    int n; // 列数
    int numDistinctIslands(vector<vector<int>>& grid) {
        m = grid.size(); 
        n = grid[0].size();
        unordered_set<string> set;// 使用哈希集合来存储字符串
        // 遍历二维数组中的每个点
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果当前点是陆地，就扩散
                if(grid[i][j] == 1){
                    string str = "";
                    dfs(grid,i,j,str);
                    set.insert(str);
                }
            }
        }
        return set.size();
    }
    void dfs(vector<vector<int>>& grid,int i,int j,string& str){
        // 如果当前点超出范围就返回
        if(i<0||i>=m||j<0||j>=n)return;
        // 如果当前点不是陆地就返回
        if(grid[i][j]==0)return;
        grid[i][j]=0;// 遍历过就标记为2
        // 向四周遍历
        dfs(grid,i-1,j,str);// 向左遍历
        str += '1';
        dfs(grid,i+1,j,str);// 向右遍历
        str += '2';
        dfs(grid,i,j-1,str);// 向上遍历
        str += '3';
        dfs(grid,i,j+1,str);// 向下遍历
        str += '4';
    }
};

二、求岛屿的周长

463. 岛屿的周长（简单难度）

输入一个二维网格grid，其中1表示陆地，0表示水域，整个网格被水完全包围，如果陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿，求网格的所有岛屿的周长之和。

 点评：

设计dfs函数从[i,j]出发向四周遍历，返回四个方向边界和湖水的个数，那么就可以得到一个岛屿的周长。

本题的题意是矩阵中始终只会有一个岛屿，我们的代码求的是所有岛屿的周长之和，更进一步：

class Solution {
public:
    /* 该题中没有岛内湖，则所有的边长只有两种可能：边界或者湖*/
    int m;
    int n;
    int islandPerimeter(vector<vector<int>>& grid) {
        m = grid.size(); 
        n = grid[0].size();
        int res=0;
        // 遍历二维数组中的每个点
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                // 如果当前点是陆地，就扩散
                if(grid[i][j] == 1){
                    res+=dfs(grid,i,j);
                }
            }
        }
        return res;
    }
    // 从[i,j]出发向四周遍历，返回四个方向边界和湖水的个数
    int dfs(vector<vector<int>>& grid,int i,int j){
        // 如果当前点超出范围,可做周长
        if(i<0||i>=m||j<0||j>=n) return 1;
        // 如果当前点是湖水，可做周长
        if(grid[i][j]==0) return 1;
        // 如果当前点已遍历过，不可做周长
        if(grid[i][j]==2) return 0;
        grid[i][j]=2;// 遍历过就标记为2
        // 向四周遍历
        int res=0;
        res+=dfs(grid,i-1,j);// 向左遍历
        res+=dfs(grid,i+1,j);// 向右遍历
        res+=dfs(grid,i,j-1);// 向上遍历
        res+=dfs(grid,i,j+1);// 向下遍历
        return res;
    }
};

三、求岛屿的面积

695. 岛屿的最大面积（中等难度）

剑指 Offer II 105. 岛屿的最大面积（中等难度）

 输入一个二维网格grid，其中1表示陆地，0表示水域，如果陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿。假设四周都被谁包围，求grid中最大的岛屿面积，如果没有岛屿，返回0。

 点评：

该题目求所有岛屿的最大面积，我们可以用dfs函数求出一个岛屿的面积，最后保存下面积最大的数即可。

改造dfs函数使其返回一个整型面积，显然在grid[i][j]的面积=向上下左右搜索的面积之和+1

注意该题目中的矩阵最大为50阶。

class Solution {
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        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=max(res,dfs(grid,i,j));//记录每个点遍历的面积的最大值
                }
            }
        }
        return res;
    }
    // 搜索[i,j]向四周扩散后能获得的最大面积
    int dfs(vector<vector<int>>& grid,int i,int j){
        // 如果当前点超出范围就返回
        if(i<0||i>=grid.size()||j<0||j>=grid[0].size()) return 0;
        // 如果当前点不是陆地就返回
        if(grid[i][j]!=1)return 0;
        // 如果当前点已经遍历过,直接返回
        if(grid[i][j]==-1)return 0;
        grid[i][j]=-1;// 遍历过就标记为-1
        // 向四周遍历
        int size =1;
        size+=dfs(grid,i-1,j);// 向左遍历
        size+=dfs(grid,i+1,j);// 向右遍历
        size+=dfs(grid,i,j-1);// 向上遍历
        size+=dfs(grid,i,j+1);// 向下遍历
        return size;
    }
};

1020. 飞地的数量（中等难度）

 输入一个二维网格grid，其中1表示陆地，0表示水域，如果陆地格子水平和垂直方向相连（对角线方向不相连）则形成一个岛屿。一次移动是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过grid的边界。返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。

点评：

该题目和「 1254.统计封闭岛屿的数目」非常相似，这题不求封闭岛屿的数量，而是求封闭岛屿的面积总和。

注意该题中 1 代表陆地，0 代表海水。

class Solution {
public:
    /*简单讲，本题就是求解所有封闭岛屿的面积，靠近边界的岛屿就不是封闭岛屿*/
    int m;
    int n;
    int numEnclaves(vector<vector<int>>& grid) {
        m=grid.size();
        n=grid[0].size();
        // 遍历二维数组中的每个点
        int res=0;
        for(int i=0;i<m;++i){
            for(int j=0;j<n;++j){
                bool isClosed=false;
                int size=dfs(grid,i,j,isClosed);// 如果是非封闭岛屿则
                if(!isClosed) res+=size;
            }
        }
        return res;
    }
    int dfs(vector<vector<int>>& grid,int i,int j,bool& isClosed){
        if(i<0||i>=m||j<0||j>=n){
            isClosed=true;
            return 0;
        }
        if(grid[i][j]==0) return 0;
        grid[i][j]=0;
        int size=1;
        size+=dfs(grid,i-1,j,isClosed);
        size+=dfs(grid,i+1,j,isClosed);
        size+=dfs(grid,i,j-1,isClosed);
        size+=dfs(grid,i,j+1,isClosed);
        return size;
    }
};

 四、求矩阵的最长递增路径

329. 矩阵中的最长递增路径（困难难度）

输入一个二维网格整数矩阵matrix，找出其中最长递增路径的长度，对于每个单元格，你可以向上下左右四个方向移动，矩阵最大阶数为200,（建议记忆化搜索）。

 点评：

该题目求矩阵的最长递增路径，我们可以用dfs函数求出从matrix[i][j]出发向四个方向搜索的最大连续递增长度，显然该长度是四个方向结果的最大值+1。

注意该题目中的矩阵最大为200阶，其题目计算量较大，容易超时，所以我们需要加入一个记忆化搜索，

简单说，我们的visited数组直接保存在matrix[i][j]的最长递增路径，这样面对相同的点就不会重复搜索

class Solution {
public:
    /* 从一个格子开始向上下左右搜索，如果四周存在小于它的，遍历过需要标记
    那么其最大连续递增长度即为周围小于它的格子的最大连续递增长度中的最大值+1
    */
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int res = 0;
        vector<vector<int>> visited = vector< vector<int> > (matrix.size(), vector <int> (matrix[0].size()));
        // 遍历二维数组中的每个点
        for(int i = 0; i < matrix.size(); i++){
            for(int j = 0; j <matrix[0].size(); j++){
                // 如果当前点没有遍历过
                if(visited[i][j]==0){
                    res=max(res,dfs(matrix,i,j,-1,visited));
                }
            }
        }
        return res;
    }
     int dfs(vector<vector<int>>& matrix,int i,int j,int last,vector<vector<int>>& visited){
        // 如果当前点超出范围就返回
        if(i<0||i>=matrix.size()||j<0||j>=matrix[0].size()) return 0;
        // 如果当前点比上一个点小就返回
        if(matrix[i][j]<=last)return 0;
        // 如果当前点已经计算过，就直接返回最大路径
        if(visited[i][j] != 0) return visited[i][j];
        // 向四周遍历,取最大方向
        int size =0;
        int tmp=matrix[i][j];
        size=max(size,dfs(matrix,i-1,j,tmp,visited));// 向左遍历
        size=max(size,dfs(matrix,i+1,j,tmp,visited));// 向右遍历
        size=max(size,dfs(matrix,i,j-1,tmp,visited));// 向上遍历
        size=max(size,dfs(matrix,i,j+1,tmp,visited));// 向下遍历
        // 标记当前点已经遍历过
        visited[i][j]=size+1;
        return visited[i][j];
    }
};

 五、在矩阵中匹配字符串

79. 单词搜索（中等难度）

剑指 Offer 12. 矩阵中的路径（中等难度）

输入一个二维网格字符矩阵board和一个字符串word，问word是否存在于board中。找出其中最长递增路径的长度，对于每个单元格，单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

 点评：

该题目求字符矩阵中是否存在一个字符串，我们可以用dfs函数求出从board[i][j]出发向四个方向搜索如果有一个方向匹配即可，显然dfs函数要传入字符串word和它的当前匹配索引k。

注意本题中求一个点board[i][j]后需要回溯，因为其遍历过的点之后可能还需要遍历

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        // 遍历二维数组中的每个点
        for(int i=0;i<board.size();++i){
            for(int j=0;j<board[0].size();++j){
                // 如果当前点满足测试条件
                if(board[i][j]==word[0]){
                    // 遍历测试
                    if(dfs(board,word,i,j,0)) return true;
                }
            }
        }
        return false;
    }
    bool dfs(vector<vector<char>>& board,string& word,int i,int j,int k){
        // 如果当前点超出范围
        if(k==word.size()) return true;
        // 如果当前点超出范围
        if(i<0||i>=board.size()||j<0||j>=board[0].size()) return false;
        // 如果当前点不匹配字符
        if(board[i][j]!=word[k]) return false;
        // 进入
        char tmp=board[i][j];
        board[i][j]='0';// 遍历过就标记为0
        // 向四周遍历
        bool res=dfs(board,word,i-1,j,k+1)||// 向左遍历
        dfs(board,word,i+1,j,k+1)||// 向右遍历
        dfs(board,word,i,j-1,k+1)||// 向上遍历
        dfs(board,word,i,j+1,k+1);// 向下遍历
        // 回溯
        board[i][j]=tmp;// 下一个点还可以遍历
        return res;
    }
};

魔法攻城狮MRL
关注
  • 2
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法系列--LeetCode（三）矩阵求岛屿数量
Joker_honey的博客
08-24 1373
一个N*M的矩阵只有0、1两种元素，1为陆地0为海洋。相邻（上下左右四个方向）即为同一块陆地，输出矩阵中岛屿数量。 算法的“广度优先”还是“深度优先”：     1.广度：一行一行遍历记录岛屿状态以及岛屿产生与合并情况。     2.深度：从一个节点开始四个方向去寻找连接岛屿，并标记寻找过的位置。 这里采用的是深度优先递归实现，非递归实现需要借助栈。 代码：  /** * 二维矩阵...
岛屿问题系列
jinghe的知识屋
04-17 2681
4. 岛屿问题一：岛屿数量 给你一个由1（陆地）和0（水）组成的二维网格，请你计算网格中岛屿的数量 岛屿总是被水包围，并且每座岛屿只能由水平方向和、或竖直方向上相邻的陆地连接而形成。 此外，你可以假设该网格的四条边均被水包围。 思路：深度优先搜索 二叉树DFS 我们先理解二叉树上的DFS遍历方法，再类比写出网格结构上的DFS遍历。 void traverse(TreeNode* root) { if (root == nullptr) { return ; } // 访问那两个相邻节点：左子节点
基础算法——深度优先经典——岛屿问题
MDeleter的博客
01-17 3196
在此之前，我曾见过许多的学生提及算法唯恐避之不及，几乎所有人都知道算法只不过是思考问题的方法，但很遗憾，大部分人并未体会到算法的乐趣所在，而是被所谓的一些优秀者口中的“神圣”的算法策略给唬住，而不敢向前。
【经典算法】LeetCode 200. 岛屿数量(Java/C/Python3/Go实现含注释说明,中等)
最新发布
2401_84427485的博客
05-05 1345
方式优点缺点时间复杂度空间复杂度DFS实现简单，容易理解在最坏情况下，空间复杂度较高O(mn)O(mn)（DFS栈空间）
算法学习-深度优先遍历（持续更新中）
蒋大钊的博客
07-17 1578
深度优先遍历可以说是力扣以及大厂面试中最常见的题型了，因为其能够和很多类型的题目联合起来解题。笔者为了能够掌握这种搜索技巧，因此对自己的刷题路径和理解进行了汇总整理。
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
这个递归版本的实现有问题，因为它会导致栈溢出（Maximum call stack size exceeded），因为广度优先遍历不适合递归实现。 - **非递归版本**： ```javascript function wideTraversal(selectNode) { var nodes...
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
本文详细介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，通过实例代码展示了深度优先遍历和广度优先遍历的实现过程，并对二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧进行了详细...
图的遍历-深度优先遍历问题
05-04
【深度优先遍历】是一种在图或树结构中进行遍历的方法，它的基本思路是从一个节点开始，尽可能深地探索图的分支。当一个节点的所有未访问过的邻接节点都被访问后，才回溯到其上一个节点，再选择一个未访问的邻接节点...
MATLAB实现迷宫的递归深度优先遍历算法
09-24
深度优先遍历是一种图遍历策略，特别适合解决寻找路径的问题，如在迷宫中找到从起点到终点的所有可能路径。 首先，我们要理解迷宫可以被抽象为一个二维矩阵，其中0代表可通行的路径，1代表障碍物。DFS算法的基本...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
一些算法（美丽的小岛）
04-06
一些算法（美丽的小岛》，是几个比较有趣的收集。
leecode算法整理——岛屿问题（dfs/bfs）
AxIOIJGDSS的博客
10-16 121
简单记录一下这类题型的解题思路。
【算法学习系列第一章】 深度优先遍历（DFS）思路及经典例题讲解
qq_51502732的博客
07-14 1786
想学习DFS的可以看这一篇，DFS主要是一种思想，通过具体题目我们会理解的更加深刻，希望对你有所帮助
DFS、BFS详解之二维矩阵路径问题
08-04 718
DFS
DFS/BFS 算法遍历二维数组-----岛屿问题解决
小黑同学的博客
07-12 1372
岛屿系列算法问题是经典的面试高频题，这里参考labuladong的一文秒杀所有岛屿问题，写出了关于C++的DFS/BFS的框架，供以后复习回顾。
DFS深度优先遍历经典例题总结
weixin_45559159的博客
02-05 3834
DFS的大概模板 void dfs(int x)//关于传入参数问题，根据题意而定，看在题目运行的过程中，哪些是在变得 { if(满足输出条件) { 输出解; return ; } if(目前已经没有必要进行下去的条件){ return ; }//剪枝操作 //如果传入的条件，还需要继续搜下去，分析每一...
岛屿问题学习
qq_42100790的博客
12-19 524
岛屿问题是一类图的遍历问题，需要在图的结构上进行DFS（深度优先搜索），虽然理论懂但是上手就抓瞎，岛屿问题是网格DFS的代表问题，正好结合讲解学习一下，主要参考这里。 典型的岛屿问题有如下： 岛屿数量 岛屿周长 岛屿的最大面积 网格搜索问题 网格搜索问题就是在由m×nm\times nm×n个小方格组成的网格上进行搜索。在岛屿类问题中，认为网格中数字为000的为海洋、数字为111的是陆地，当相邻的格子数字相同时，就看作就一片连起来的岛屿。 根据图就可以引申出岛屿面积、岛屿周长等一系列问题，而这类问题都可以
岛屿问题-DFS
weixin_47676610的博客
06-20 286
DFS遍历框架 我们所熟悉的 DFS（深度优先搜索）问题通常是在树或者图结构上进行的。而我们今天要讨论的 DFS 问题，是在一种「网格」结构中进行的。岛屿问题是这类网格 DFS 问题的典型代表。网格结构遍历起来要比二叉树复杂一些，如果没有掌握一定的方法，DFS 代码容易写得冗长繁杂。本文将以岛屿问题为例，展示网格类问题 DFS 通用思路，以及如何让代码变得简洁。 网格类问题的 DFS 遍历方法 网格问题的基本概念 我们首先明确一下岛屿问题中的网格结构是如何定义的，以方便我们后面的讨论。网格问题是由 m×n
算法题解：岛屿的数量（JAVA代码）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
07-07 2099
算法题解：岛屿的数量（JAVA代码） 给定一个二维数组，数组元素由0和1组成。0代表水，1代表陆地。陆地可以形成岛。 如果上下左右，包括对角线方向如有相邻的陆地（1）则可以形成岛。如下图所示。 编写一个算法，求岛的数量。 例如：规定一个二维数组： {1, 1, 0, 0, 0}, {0, 1, 0, 0, 1}, {1, 0, 0, 1, 1}, {0, 0, 0, 0, 0}, {1...
深度优先遍历和广度优先遍历区别
10-24
深度优先遍历和广度优先遍历是两种常见的树和图的遍历算法。它们的主要区别在于遍历的顺序不同。 深度优先遍历(Depth First Search)是一种先访问子节点，再访问父节点的遍历方式。具体来说，深度优先遍历会先访问根节点，然后递归地访问左子树，直到左子树访问完毕后再递归地访问右子树。因此，深度优先遍历的顺序是根节点、左子树、右子树。 广度优先遍历(Breadth First Search)是一种先访问同一层节点，再访问下一层节点的遍历方式。具体来说，广度优先遍历会先访问根节点，然后访问根节点的所有子节点，接着访问子节点的所有子节点，以此类推。因此，广度优先遍历的顺序是按照层次依次访问。 总的来说，深度优先遍历和广度优先遍历的区别在于遍历的顺序不同，深度优先遍历是先访问子节点，再访问父节点，而广度优先遍历是先访问同一层节点，再访问下一层节点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

魔法攻城狮MRL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值