牛客题解 | 序列化二叉树

二叉树序列化与矩阵岛屿问题题解
原创 已于 2025-03-04 10:00:19 修改 · 846 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #力扣 #面试 #算法力扣

于 2025-03-04 09:59:49 首次发布

题目## 题目

题目链接

#描述
这是一篇针对初学者的题解，共用两种方法解决。
知识点：二叉树，先序遍历，层次遍历
难度：二星

#题解
题目描述：给定一颗二叉树，将其序列化和反序列化。

##方法一：先序遍历实现
预备知识：先序遍历的递归实现：

void pre_order(TreeNode *root) {
	if (!root) {
		return;
	}

	// process root
	// ...
	pre_order(root->left);
	pre_order(root->right);
}

对于本题来说，可以套用上述模板。
假设序列化的结果为字符串 str, 初始str = “”.根据要求，遇到nullptr节点，str += “#”
遇到非空节点，str += “val” + “!”; 假设val为3， 就是 str += “3!”

所以，序列化二叉树的代码为：

char* Serialize(TreeNode *root) {    
    if (!root) {
        return "#";
    }

    string res = to_string(root->val);
    res.push_back(',');

    char* left = Serialize(root->left);
    char* right = Serialize(root->right);

    char* ret = new char[strlen(left)+strlen(right)+res.size()];
    // 如果是string类型，直接用operator += ,这里char* 需要用函数
    strcpy(ret,res.c_str());
    strcat(ret,left);
    strcat(ret,right);

    return ret;
}

反序列化的结果，就是根据先序遍历，再重建二叉树即可。
代码如下：

// 参数使用引用&， 以实现全局变量的目的
TreeNode* deseri(char *&s) {
	if (*s == '#') {
		++s;
		return nullptr;
	}
	
    // 构造根节点值
	int num = 0;
	while (*s != ',') {
		num = num * 10 + (*s - '0');
		++s;
	}
	++s; 
    // 递归构造树
	TreeNode *root = new TreeNode(num);
	root->left = deseri(s);
	root->right = deseri(s);

	return root;
}

TreeNode* Deserialize(char *str) {
	return deseri(str);
}

所以，最终的代码如下：

class Solution {
public:
    char* Serialize(TreeNode *root) {    
        if (!root) {
            return "#";
        }
        string res = to_string(root->val);
        res.push_back(',');
        char* left = Serialize(root->left);
        char* right = Serialize(root->right);
        char* ret = new char[strlen(left)+strlen(right)+res.size()];
        // 如果是string类型，直接用operator += ,这里char* 需要用函数
        strcpy(ret,res.c_str());
        strcat(ret,left);
        strcat(ret,right);
        return ret;
    }
    TreeNode* deseri(char *&s) {
        if (*s == '#') {
            ++s;
            return nullptr;
        }
        // 构造根节点值
        int num = 0;
        while (*s != ',') {
            num = num * 10 + (*s - '0');
            ++s;
        }
        ++s; 
        // 递归构造树
        TreeNode *root = new TreeNode(num);
        root->left = deseri(s);
        root->right = deseri(s);
        return root;
    }

    TreeNode* Deserialize(char *str) {
        return deseri(str);
    }
};

中序遍历，后序遍历大致都差不多。

##方法二：层次遍历实现
层次遍历采用队列实现。跟先序遍历的思想差不多，无非都是把树的所有数据遍历一遍，然后记录下来。
层次遍历模板：

void bfs(TreeNode *root){
    queue<treenode*> qt;
    qt.push(root);
 	string s;
    while (!qt.empty())
    {
    	// pop operator
        TreeNode *node = qt.front();
        qt.pop();

        // process node
        if (node == NULL)
        {
            s.push_back('#');
            s.push_back(',');
            continue;
        }
        s += to_string(node-&gt;val);
        s.push_back(',');

        // push operator
        qt.push(node-&gt;left);
        qt.push(node-&gt;right);
 
    }
}

序列化的操作直接根据模板套即可。代码如下：

char* Serialize(TreeNode *root)
    {
        string s;
        queue<TreeNode*> qt;
        qt.push(root);

        while (!qt.empty())
        {
            // pop operator
            TreeNode *node = qt.front();
            qt.pop();
            // process null node
            if (node == nullptr)
            {
                s.push_back('#');
                s.push_back(',');
                continue;
            }
            // process not null node
            s += to_string(node->val);
            s.push_back(',');
            // push operator
            qt.push(node->left);
            qt.push(node->right);

        }

        char *ret = new char[s.length() + 1];
        strcpy(ret, s.c_str());

        return ret;
    }

反序列化就是根据层次遍历在走一遍即可。
代码如下：

    TreeNode* Deserialize(char *str)
    {
        if (str == nullptr) {
            return nullptr;
        }
        // 可用string成员函数
        string s(str);
        if (str[0] == '#') {
            return nullptr;
        }

        // 构造头结点
        queue<TreeNode*> nodes;
        TreeNode *ret = new TreeNode(atoi(s.c_str()));
        s = s.substr(s.find_first_of(',') + 1);
        nodes.push(ret);
        // 根据序列化字符串再层次遍历一遍，来构造树
        while (!nodes.empty() && !s.empty())
        {
            TreeNode *node = nodes.front();
            nodes.pop();
            if (s[0] == '#')
            {
                node->left = nullptr;
                s = s.substr(2);
            }
            else
            {
                node->left = new TreeNode(atoi(s.c_str()));
                nodes.push(node->left);
                s = s.substr(s.find_first_of(',') + 1);
            }

            if (s[0] == '#')
            {
                node->right = nullptr;
                s = s.substr(2);
            }
            else
            {
                node->right = new TreeNode(atoi(s.c_str()));
                nodes.push(node->right);
                s = s.substr(s.find_first_of(',') + 1);
            }
        }
        return ret;
    }

所以，最终的代码是：

class Solution {
public:
    char* Serialize(TreeNode *root)
    {
        string s;
        queue<TreeNode*> qt;
        qt.push(root);

        while (!qt.empty())
        {
            // pop operator
            TreeNode *node = qt.front();
            qt.pop();
            // process null node
            if (node == nullptr)
            {
                s.push_back('#');
                s.push_back(',');
                continue;
            }
            // process not null node
            s += to_string(node->val);
            s.push_back(',');
            // push operator
            qt.push(node->left);
            qt.push(node->right);

        }

        char *ret = new char[s.length() + 1];
        strcpy(ret, s.c_str());

        return ret;
    }
    TreeNode* Deserialize(char *str)
    {
        if (str == nullptr) {
            return nullptr;
        }
        // 可用string成员函数
        string s(str);
        if (str[0] == '#') {
            return nullptr;
        }

        // 构造头结点
        queue<TreeNode*> nodes;
        TreeNode *ret = new TreeNode(atoi(s.c_str()));
        s = s.substr(s.find_first_of(',') + 1);
        nodes.push(ret);
        // 根据序列化字符串再层次遍历一遍，来构造树
        while (!nodes.empty() && !s.empty())
        {
            TreeNode *node = nodes.front();
            nodes.pop();
            if (s[0] == '#')
            {
                node->left = nullptr;
                s = s.substr(2);
            }
            else
            {
                node->left = new TreeNode(atoi(s.c_str()));
                nodes.push(node->left);
                s = s.substr(s.find_first_of(',') + 1);
            }

            if (s[0] == '#')
            {
                node->right = nullptr;
                s = s.substr(2);
            }
            else
            {
                node->right = new TreeNode(atoi(s.c_str()));
                nodes.push(node->right);
                s = s.substr(s.find_first_of(',') + 1);
            }
        }
        return ret;
    }
};

此题主要考察对树的遍历和构造树。</treenode*></treenode*></treenode*>

题目链接

题目主要信息：
  • 给一个01矩阵，1代表是陆地，0代表海洋，如果两个1相邻，则这两个1属于同一个岛
  • 只考虑上下左右为相邻
  • 判断岛屿的个数
举一反三：

学习完本题的思路你可以解决如下题目：

BM61. 矩阵最长递增路径

方法一：dfs（推荐使用）

知识点：深度优先搜索（dfs）
深度优先搜索一般用于树或者图的遍历，其他有分支的（如二维矩阵）也适用。它的原理是从初始点开始，一直沿着同一个分支遍历，直到该分支结束，然后回溯到上一级继续沿着一个分支走到底，如此往复，直到所有的节点都有被访问到。

思路：

矩阵中多处聚集着1，要想统计1聚集的堆数而不重复统计，那我们可以考虑每次找到一堆相邻的1，就将其全部改成0，而将所有相邻的1改成0的步骤又可以使用深度优先搜索（dfs）：当我们遇到矩阵的某个元素为1时，首先将其置为了0，然后查看与它相邻的上下左右四个方向，如果这四个方向任意相邻元素为1，则进入该元素，进入该元素之后我们发现又回到了刚刚的子问题，又是把这一片相邻区域的1全部置为0，因此可以用递归实现。

//后续四个方向遍历
if(i - 1 >= 0 && grid[i - 1][j] == '1') 
    dfs(grid, i - 1, j);
if(i + 1 < n && grid[i + 1][j] == '1') 
    dfs(grid, i + 1,j);
if(j - 1 >= 0 && grid[i][j - 1] == '1') 
    dfs(grid, i, j - 1);
if(j + 1 < m && grid[i][j + 1] == '1') 
    dfs(grid, i, j + 1);
  • 终止条件： 进入某个元素修改其值为0后，遍历四个方向发现周围都没有1，那就不用继续递归，返回即可，或者递归到矩阵边界也同样可以结束。
  • 返回值： 每一级的子问题就是把修改后的矩阵返回，因为其是函数引用，也不用管。
  • 本级任务： 对于每一级任务就是将该位置的元素置为0，然后查询与之相邻的四个方向，看看能不能进入子问题。

具体做法：

  • step 1：优先判断空矩阵等情况。
  • step 2：从上到下从左到右遍历矩阵每一个位置的元素，如果该元素值为1，统计岛屿数量。
  • step 3：接着将该位置的1改为0，然后使用dfs判断四个方向是否为1，分别进入4个分支继续修改。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    //深度优先遍历与i，j相邻的所有1
    public void dfs(char[][] grid, int i, int j) { 
        int n = grid.length;
        int m = grid[0].length;
        // 置为0
        grid[i][j] = '0'; 
        //后续四个方向遍历
        if(i - 1 >= 0 && grid[i - 1][j] == '1') 
            dfs(grid, i - 1, j);
        if(i + 1 < n && grid[i + 1][j] == '1') 
            dfs(grid, i + 1,j);
        if(j - 1 >= 0 && grid[i][j - 1] == '1') 
            dfs(grid, i, j - 1);
        if(j + 1 < m && grid[i][j + 1] == '1') 
            dfs(grid, i, j + 1);
    }
    
    public int solve (char[][] grid) {
        int n = grid.length;
        //空矩阵的情况
        if (n == 0)  
            return 0;
        int m = grid[0].length;
        //记录岛屿数
        int count = 0; 
        //遍历矩阵
        for(int i = 0; i < n; i++){ 
            for(int j = 0; j < m; j++){
                //遍历到1的情况
                if(grid[i][j] == '1'){ 
                    //计数
                    count++; 
                    //将与这个1相邻的所有1置为0
                    dfs(grid, i, j); 
                }
            }
        }
        return count;
    }
}

C++实现代码：

class Solution {
public:
    //深度优先遍历与i，j相邻的所有1
    void dfs(vector<vector<char>>& grid, int i, int j) { 
        int n = grid.size();
        int m = grid[0].size();
        //置为0
        grid[i][j] = '0'; 
        //后续四个方向遍历
        if(i - 1 >= 0 && grid[i - 1][j] == '1') 
            dfs(grid, i - 1, j);
        if(i + 1 < n && grid[i + 1][j] == '1') 
            dfs(grid, i + 1,j);
        if(j - 1 >= 0 && grid[i][j - 1] == '1') 
            dfs(grid, i, j - 1);
        if(j + 1 < m && grid[i][j + 1] == '1') 
            dfs(grid, i, j + 1);
    }
    int solve(vector<vector<char> >& grid) {
        int n = grid.size();
        //空矩阵的情况
        if (n == 0)  
            return 0;
        int m = grid[0].size();
        //记录岛屿数
        int count = 0; 
        //遍历矩阵
        for(int i = 0; i < n; i++){ 
            for(int j = 0; j < m; j++){
                //遍历到1的情况
                if(grid[i][j] == '1'){ 
                    //计数
                    count++; 
                    //将与这个1相邻的所有1置为0
                    dfs(grid, i, j); 
                }
            }
        }
        return count;
    }
};

Python实现代码：

class Solution:
    #深度优先遍历与i，j相邻的所有1
    def dfs(self, grid:List[List[chr]], i:int, j:int) : 
        n = len(grid)
        m = len(grid[0])
        #置为0
        grid[i][j] = '0' 
        #后续四个方向遍历
        if i - 1 >= 0 and grid[i - 1][j] == '1':
            self.dfs(grid, i - 1, j)
        if i + 1 < n and grid[i + 1][j] == '1':
            self.dfs(grid, i + 1, j)
        if j - 1 >= 0 and grid[i][j - 1] == '1':
            self.dfs(grid, i, j - 1)
        if j + 1 < m and grid[i][j + 1] == '1':
            self.dfs(grid, i, j + 1)
            
    def solve(self , grid: List[List[str]]) -> int:
        n = len(grid)
        #空矩阵的情况
        if  n == 0: 
            return 0
        m = len(grid[0])
        #记录岛屿数
        count = 0 
        #遍历矩阵
        for i in range(n): 
            for j in range(m):
                #遍历到1的情况
                if grid[i][j] == '1': 
                    #计数
                    count += 1 
                    #将与这个1相邻的所有1置为0
                    self.dfs(grid, i, j) 
        return count

复杂度分析：

  • 时间复杂度： O ( n m ) O(nm) O(nm)，其中 m m m、 n n n为矩阵的长和宽，需要遍历整个矩阵，每次dfs搜索需要经过每个值为1的元素，但是最坏情况下也只是将整个矩阵变成0，因此相当于最坏遍历矩阵2次
  • 空间复杂度： O ( n m ) O(nm) O(nm)，最坏情况下整个矩阵都是1，递归栈深度为 m n mn mn
方法二：bfs（扩展思路）

知识点：广度优先搜索（bfs）

广度优先搜索与深度优先搜索不同，它是将与某个节点直接相连的其它所有节点依次访问一次之后，再往更深处，进入与其他节点直接相连的节点。bfs的时候我们常常会借助队列的先进先出，因为从某个节点出发，我们将与它直接相连的节点都加入队列，它们优先进入，则会优先弹出，在它们弹出的时候再将与它们直接相连的节点加入，由此就可以依次按层访问。

思路：

统计岛屿的方法可以和方法一同样遍历解决，为了去重我们还是要将所有相邻的1一起改成0，这时候同样遍历连通的广度优先搜索（bfs）可以代替dfs。

具体做法：

  • step 1：优先判断空矩阵等情况。
  • step 2：从上到下从左到右遍历矩阵每一个位置的元素，如果该元素值为1，统计岛屿数量。
  • step 3：使用bfs将遍历矩阵遇到的1以及相邻的1全部置为0：利用两个队列辅助（C++可以使用pair），每次队列进入第一个进入的1，然后遍历队列，依次探讨队首的四个方向，是否符合，如果符合则置为0，且位置坐标加入队列，继续遍历，直到队列为空。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int solve (char[][] grid) {
        int n = grid.length;
        //空矩阵的情况
        if (n == 0)  
            return 0;
        int m = grid[0].length;
        //记录岛屿数
        int count = 0; 
        //遍历矩阵
        for(int i = 0; i < n; i++){ 
            for(int j = 0; j < m; j++){
                //遇到1要将这个1及与其相邻的1都置为0
                if(grid[i][j] == '1'){  
                    //岛屿数增加
                    count++; 
                    grid[i][j] = '0';
                    //记录后续bfs的坐标
                    Queue<Integer> q1 = new LinkedList<Integer>();
                    Queue<Integer> q2 = new LinkedList<Integer>();
                    q1.offer(i);
                    q2.offer(j);
                    //bfs
                    while(!q1.isEmpty()){ 
                        int row = q1.poll();
                        int col = q2.poll();
                        //四个方向依次检查：不越界且为1
                        if(row - 1 >= 0 && grid[row - 1][col] == '1'){
                            q1.offer(row - 1);
                            q2.offer(col);
                            grid[row - 1][col] = '0';
                        }
                        if(row + 1 < n && grid[row + 1][col] == '1'){
                            q1.offer(row + 1);
                            q2.offer(col);
                            grid[row + 1][col] = '0';
                        }
                        if(col - 1 >= 0 && grid[row][col - 1] == '1'){
                            q1.offer(row);
                            q2.offer(col - 1);
                            grid[row][col - 1] = '0';
                        }
                        if(col + 1 < m && grid[row][col + 1] == '1'){
                            q1.offer(row);
                            q2.offer(col + 1);
                            grid[row][col + 1] = '0';
                        }
                    }
                }
            }
        }
        return count;
    }
}

C++实现代码：

class Solution {
public:
    int solve(vector<vector<char> >& grid) {
        int n = grid.size();
        //空矩阵的情况
        if(n == 0)   
            return 0;
        int m = grid[0].size();
        //记录岛屿数
        int count = 0; 
        //遍历矩阵
        for(int i = 0; i < n; i++){ 
            for(int j = 0; j < m; j++){
                //遇到1要将这个1及与其相邻的1都置为0
                if(grid[i][j] == '1'){  
                    //岛屿数增加
                    count++; 
                    grid[i][j] = '0';
                    //记录后续bfs的坐标
                    queue<pair<int, int>> q; 
                    q.push({i, j}); 
                    //bfs
                    while(!q.empty()){ 
                        auto temp = q.front();
                        q.pop();
                        int row = temp.first;
                        int col = temp.second;
                        //四个方向依次检查：不越界且为1
                        if(row - 1 >= 0 && grid[row - 1][col] == '1'){
                            q.push({row - 1, col});
                            grid[row - 1][col] = '0';
                        }
                        if(row + 1 < n && grid[row + 1][col] == '1'){
                            q.push({row + 1, col});
                            grid[row + 1][col] = '0';
                        }
                        if(col - 1 >= 0 && grid[row][col - 1] == '1'){
                            q.push({row, col - 1});
                            grid[row][col - 1] = '0';
                        }
                        if(col + 1 < m && grid[row][col + 1] == '1'){
                            q.push({row, col + 1});
                            grid[row][col + 1] = '0';
                        }
                    }
                }
            }
        }
        return count;
    }
};

Python实现代码：

from queue import Queue,LifoQueue,PriorityQueue

class Solution:
    def solve(self , grid: List[List[str]]) -> int:
        n = len(grid)
        #空矩阵的情况
        if n == 0:  
            return 0
        m = len(grid[0])
        #记录岛屿数
        count = 0 
        #遍历矩阵
        for i in range(n): 
            for j in range(m):
                #遇到1要将这个1及与其相邻的1都置为0
                if grid[i][j] == '1':  
                    #岛屿数增加
                    count += 1 
                    grid[i][j] = '0'
                    #记录后续bfs的坐标
                    q = Queue() 
                    q.put([i, j])
                    #bfs
                    while not q.empty(): 
                        temp = q.get()
                        row = temp[0]
                        col = temp[1]
                        #四个方向依次检查：不越界且为1
                        if row - 1 >= 0 and grid[row - 1][col] == '1':
                            q.put([row - 1, col])
                            grid[row - 1][col] = '0'
                        if row + 1 < n and grid[row + 1][col] == '1':
                            q.put([row + 1, col])
                            grid[row + 1][col] = '0'
                        if col - 1 >= 0 and grid[row][col - 1] == '1':
                            q.put([row, col - 1])
                            grid[row][col - 1] = '0'
                        if col + 1 < m and grid[row][col + 1] == '1':
                            q.put([row, col + 1])
                            grid[row][col + 1] = '0'
        return count

复杂度分析：

  • 时间复杂度： O ( n m ) O(nm) O(nm)，其中 m m m、 n n n为矩阵的长和宽，需要遍历整个矩阵，每次bfs搜索需要经过每个值为1的元素，但是最坏情况下也只是将整个矩阵变成0，因此相当于最坏遍历矩阵2次
  • 空间复杂度： ( m i n ( n , m ) ) (min(n,m)) (min(n,m))，bfs最坏情况队列大小为长和宽的较小值
牛客网 岛屿数量
BB2039
01-04 262
class Solution { public: /** * 判断岛屿数量 * @param grid char字符型vector<vector<>> * @return int整型 */ bool island(int x,int y,vector<vector<char>> &a){ return x>-1 && y>-1 && x&lt.
牛客题霸--岛屿数量
weixin_49607385的博客
11-27 203
岛屿数量 题目链接 Solution 给定一个方格图，求联通块的个数。 求联通块，并查集可做。 我们可以把所有相邻的两个是1的位置，用并查集合并起来，最后计算有多少个并查集即可。 具体实现：扫描整个地图，如果是1，看其上下左右是不是1，如果是，合并。 详见代码，附有注释。 Code class Solution { public: int n, m, f[40005], vis[40005]; int dx[4] = {0, 0, -1, 1}; int dy[4] = {-1, 1
牛客题解 | 岛屿数量
wc529065的博客
02-28 713
牛客题库题解
牛客题霸——岛屿数量(Javascript)
weixin_45727472的博客
06-12 776
一、题目地址 https://www.nowcoder.com/practice/0c9664d1554e466aa107d899418e814e?tpId=188&&tqId=38590&rp=1&ru=/ta/job-code-high-week&qru=/ta/job-code-high-week/question-ranking 二、思路地址 https://www.bilibili.com/video/BV1Y7411v7Wh 三、具体代码 /** * 判
『牛客|每日一题』岛屿数量
一个专注于客户端开发的技术er，不定期更新Android，Flutter，HormonyOS等方向的使用心得和感悟
08-10 1064
深度优先搜索一般用于树或者图的遍历，其他有分支的（如二维矩阵）也适用。它的原理是从初始点开始，一直沿着同一个分支遍历，直到该分支结束，然后回溯到上一级继续沿着一个分支走到底，如此往复，直到所有的节点都有被访问到。 2.1思路分析 整体思路就是找到一堆1就意味着找到一个岛屿，然后把他们变成0，再找下一堆1再把这堆1变成0，直到没有1为止。...
牛客题解 | 二叉树中和为某一值的路径(一)
wc529065的博客
02-21 546
牛客题库题解
牛客题解 | 连续子数组的最大和
wc529065的博客
03-08 719
牛客题库题解牛客题库题解
牛客题解 | 二叉搜索树与双向链表
wc529065的博客
02-21 701
牛客题库题解
题解 | #易理解的二叉树不同顺序遍历的迭代统一实现#
2301_79125642的博客
07-03 1062
最近大疆的校招开了，帮助大疆更好的应对面试，我分我去年面的大疆面经，时间有点久了，记录的问题可能给不。去年09-27 一面，时间大学20分钟，hr自我介绍,项目经历，软件技能，自我评价，教育经历二面，深。我走的是大疆特色的RM通道，参加过大疆的RM比赛的同学可以走这个通道，流程比普通的通道要快一点，并且。面试官很友好，盯着项目问，因为我项目主要做的静力学仿真，动力学仿真以及疲劳仿真，面试官就主要问我疲劳。9月初投递，9月21面试，首先提前4、5天通过邮箱和短信通知你面试时间，然后让你加钉钉群，通知面试消。
题解 | #合并二叉树#基于morris前序遍历的合并二叉树
2301_79125642的博客
08-24 227
昨天被HR约面，原本约下个星期，我询问能不能早点面试，就约到了今天下午[喝可乐][喝可乐] 面试前，上一场还有一个其他的面试，赶的比较急。在一家小厂实习，不到一个月，合同签了三个月，带我的mentor不是专门做Java的，需求讲不明白，不会的地方问他也讲不清楚，打算辞职，这种情况可以直接辞职吗？入职帆软快一年了，在这边遇到的同学们人都很耐丝虽然不像 BAT 那样的规模，但近 2000 人做几个都在行业头部的产品，可以与更多类型的人配合，了解到更广泛的业。
200. 岛屿数量
dev_zyx的博客
04-01 385
题目： 200. 岛屿数量 题解： 代码： /** * code200 */ public class code200 { public static int numIslands(char[][] grid) { if(grid.length == 0) { return 0; } int m...
[每日一题]99：岛屿数量
AngelDg的博客
09-15 1101
题目描述 给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。 示例1 输入 [[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]] 输出 3 备注: 01矩阵范围<=200*200 题解代码 class Solution { public: /** * 判断岛屿数量 * @
岛屿问题简单解法
qzfzz的博客
07-28 650
解题思路： 递归的把所有遇到的1全部置为0. <?php $strIsland = <<<STR 1 1 1 1 0 1 1 0 1 0 1 1 0 0 1 0 0 0 1 0 STR; $graph = []; $lines = explode(PHP_EOL, $strIsland); $row = 0; foreach( $lines as $line ) ...
牛客网刷题-岛屿数量
qq_35398517的博客
02-23 789
问题描述 给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。 示例 示例1 输入 [[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]] 输出 3 解决思路 分析 遍历数组，将相邻的岛屿的置为1（可以通过dfs或bfs的方式），然后继续判断。 方法 dfs：从一个为1的根节点开始访问，从每个相邻1节
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 152
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习与集成方法：组合多个学习器来提高整体性能
hiliang521的博客
12-02 822
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 792
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
C++ ⼀级 2024 年 03 ⽉
最新发布
weixin_46669997的博客
12-05 11
当 N 为9, 6, 3, 0时，满足条件 N % 3 == 0，因此它们被输出并跟随一个 #。要注意的是，字符串“a+1= ”最后有一个空格，因而输出的内容是：a+1= 2，答案为A。输入21，21%3的结果为0，进入if的分支，因而第4行代码可以被执行。19.【判断题】C++表达式 “10”*2 执行时将报错，因为 “10” 是字符串类型而2是整数类型，它们数据类型不同，不能在一起运算。Cout后面有两个<<，第1个输出字符串5%2=，第2个输出算术运算“5%2”的结果，为1，答案为D。
二叉树游戏牛客
04-02
### 关于二叉树的游戏与练习题 #### 构造二叉树 通过给定的先序遍历 `preorder` 和中序遍历 `inorder` 来构建一棵二叉树是一个经典的算法问题[^1]。此问题的核心在于利用先序遍历的第一个元素作为根节点，并从中序遍历中找到该根节点的位置，从而划分左子树和右子树。 以下是基于 Python 的解决方案： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def buildTree(preorder, inorder): if not preorder or not inorder: return None root_val = preorder[0] root_index_in_inorder = inorder.index(root_val) root = TreeNode(root_val) root.left = buildTree(preorder[1:root_index_in_inorder + 1], inorder[:root_index_in_inorder]) root.right = buildTree(preorder[root_index_in_inorder + 1:], inorder[root_index_in_inorder + 1:]) return root ``` #### 层序遍历与后续遍历 对于上述构造好的二叉树，可以进一步计算其层序遍历和后续遍历的结果[^2]。需要注意的是，在实际编程环境中（如 C++），由于内存分配的原因可能导致数组越界的错误，因此需要合理规划数据结构的空间大小。 以下是层序遍历的一个简单实现： ```python from collections import deque def levelOrder(root): result = [] queue = deque([root]) while queue: node = queue.popleft() if node: result.append(node.val) queue.append(node.left) queue.append(node.right) return result ``` #### 子树翻转操作 另一个常见的问题是关于二叉树的镜像翻转。可以通过递归的方式从叶子节点向上逐级反转左右子树来完成整个过程[^3]。 下面是执行这一功能的方法示例： ```python def invertTree(root): if root is None: return None temp = root.left root.left = invertTree(root.right) root.right = invertTree(temp) return root ``` ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值