题目## 题目## 题目## 题目
#描述
这是一篇针对初学者的题解，共用两种方法解决。
知识点：二叉树，先序遍历，层次遍历
难度：二星
#题解
题目描述：给定一颗二叉树，将其序列化和反序列化。
##方法一：先序遍历实现
预备知识：先序遍历的递归实现：
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->val);
s.push_back(',');
// push operator
qt.push(node->left);
qt.push(node->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*>
题目主要信息：
- 序列化二叉树即找一种顺序存储二叉树的节点，并以相同的方式能够读取序列重新构建。
- 换种说法，就是遍历二叉树，记录每个节点，再以同样的方式遍历就可以还原二叉树。
- 遍历的方法有四种：前序遍历、中序遍历、后序遍历、层次遍历，理论上只要以相同的方式序列化或者反序列化，都可以解题。
举一反三：
学习完本题的思路你可以解决如下题目：
方法：前序遍历（推荐使用）
知识点：二叉树递归
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
而二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。
思路：
序列化即将二叉树的节点值取出，放入一个字符串中，我们可以按照前序遍历的思路，遍历二叉树每个节点，并将节点值存储在字符串中，我们用‘#’表示空节点，用‘!'表示节点与节点之间的分割。
反序列化即根据给定的字符串，将二叉树重建，因为字符串中的顺序是前序遍历，因此我们重建的时候也是前序遍历，即可还原。
具体做法：
- step 1：优先处理序列化，首先空树直接返回“#”，然后调用SerializeFunction函数前序递归遍历二叉树。
SerializeFunction(root, res);
- step 2：SerializeFunction函数负责前序递归，根据“根左右”的访问次序，优先访问根节点，遇到空节点在字符串中添加‘#’，遇到非空节点，添加相应节点数字和‘!’，然后依次递归进入左子树，右子树。
//根节点
str.append(root.val).append('!');
//左子树
SerializeFunction(root.left, str);
//右子树
SerializeFunction(root.right, str);
- step 3：创建全局变量index表示序列中的下标（C++中直接指针完成）。
- step 4：再处理反序列化，读入字符串，如果字符串直接为"#"，就是空树，否则还是调用DeserializeFunction函数前序递归建树。
TreeNode res = DeserializeFunction(str);
- step 5：DeserializeFunction函数负责前序递归构建树，遇到‘#’则是空节点，遇到数字则根据感叹号分割，将字符串转换为数字后加入新创建的节点中，依据“根左右”，创建完根节点，然后依次递归进入左子树、右子树创建新节点。
TreeNode root = new TreeNode(val);
......
//反序列化与序列化一致，都是前序
root.left = DeserializeFunction(str);
root.right = DeserializeFunction(str);
图示：
Java实现代码：
import java.util.*;
public class Solution {
//序列的下标
public int index = 0;
//处理序列化的功能函数（递归）
private void SerializeFunction(TreeNode root, StringBuilder str){
//如果节点为空，表示左子节点或右子节点为空，用#表示
if(root == null){
str.append('#');
return;
}
//根节点
str.append(root.val).append('!');
//左子树
SerializeFunction(root.left, str);
//右子树
SerializeFunction(root.right, str);
}
public String Serialize(TreeNode root) {
//处理空树
if(root == null)
return "#";
StringBuilder res = new StringBuilder();
SerializeFunction(root, res);
//把str转换成char
return res.toString();
}
//处理反序列化的功能函数（递归）
private TreeNode DeserializeFunction(String str){
//到达叶节点时，构建完毕，返回继续构建父节点
//空节点
if(str.charAt(index) == '#'){
index++;
return null;
}
//数字转换
int val = 0;
//遇到分隔符或者结尾
while(str.charAt(index) != '!' && index != str.length()){
val = val * 10 + ((str.charAt(index)) - '0');
index++;
}
TreeNode root = new TreeNode(val);
//序列到底了，构建完成
if(index == str.length())
return root;
else
index++;
//反序列化与序列化一致，都是前序
root.left = DeserializeFunction(str);
root.right = DeserializeFunction(str);
return root;
}
public TreeNode Deserialize(String str) {
//空序列对应空树
if(str == "#")
return null;
TreeNode res = DeserializeFunction(str);
return res;
}
}
C++实现代码：
class Solution {
public:
//处理序列化的功能函数（递归）
void SerializeFunction(TreeNode* root, string& str){
//如果指针为空，表示左子节点或右子节点为空，用#表示
if(root == NULL){
str += '#';
return;
}
//根节点
string temp = to_string(root->val);
str += temp + '!';// 加!，区分节点
//左子树
SerializeFunction(root->left, str);
//右子树
SerializeFunction(root->right, str);
}
char* Serialize(TreeNode *root) {
//处理空树
if(root == NULL)
return "#";
string res;
SerializeFunction(root, res);
//把str转换成char
char* charRes = new char[res.length() + 1];
strcpy(charRes, res.c_str());
charRes[res.length()] = '\0';
return charRes;
}
//处理反序列化的功能函数（递归）
TreeNode* DeserializeFunction(char** str){
//到达叶节点时，构建完毕，返回继续构建父节点
//双**表示取值
if(**str == '#'){
(*str)++;
return NULL;
}
//数字转换
int val = 0;
while(**str != '!' && **str != '\0'){
val = val * 10 + ((**str) - '0');
(*str)++;
}
TreeNode* root = new TreeNode(val);
//序列到底了，构建完成
if(**str == '\0')
return root;
else
(*str)++;
//反序列化与序列化一致，都是前序
root->left = DeserializeFunction(str);
root->right = DeserializeFunction(str);
return root;
}
TreeNode* Deserialize(char *str) {
//空序列对应空树
if(str == "#"){
return NULL;
}
TreeNode* res = DeserializeFunction(&str);
return res;
}
};
Python代码实现：
import sys
#设置递归深度
sys.setrecursionlimit(100000)
class Solution:
def __init__(self):
self.index = 0
self.s = ""
#处理序列化（递归）
def SerializeFunction(self, root):
#空节点
if not root:
self.s += '#'
return
#根节点
self.s += (str)(root.val) + '!'
#左子树
self.SerializeFunction(root.left)
#右子树
self.SerializeFunction(root.right)
def Serialize(self, root):
if not root:
return '#'
self.s = ""
self.SerializeFunction(root)
return self.s
#处理反序列化的功能函数（递归）
def DeserializeFunction(self, s: str):
# 到达叶节点时，构建完毕，返回继续构建父节点
#空节点
if self.index >= len(s) or s[self.index] == "#":
self.index += 1
return None
# 数字转换
val = 0
#遇到分隔符或者结尾
while s[self.index] != '!' and self.index != len(s):
val = val * 10 + (int)(s[self.index])
self.index += 1
root = TreeNode(val)
#序列到底了，构建完成
if self.index == len(s):
return root
else:
self.index += 1
#反序列化与序列化一致，都是前序
root.left = self.DeserializeFunction(s)
root.right = self.DeserializeFunction(s)
return root
def Deserialize(self, s):
if s == "#":
return None
return self.DeserializeFunction(s)
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为二叉树节点数，前序遍历，每个节点遍历一遍
- 空间复杂度： O ( n ) O(n) O(n)，最坏情况下，二叉树退化为链表，递归栈最大深度为 n n n
题目的主要信息：
- 将给定字符串循环左移 n n n位
- 即最左边的 n n n位按照顺序整体接到右边末尾
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：三次反转（推荐使用）
思路：
循环左移相当于从第 n n n个位置开始，左右两部分视作整体翻转。即abcdefg左移3位defgabc可以看成AB翻转成BA（这里小写字母看成字符元素，大写字母看成整体）。既然是翻转我们就可以用到reverse函数。
具体做法:
- step 1：因为 n n n可能大于字符串长度，因此需要对长度 m m m取余，因为每次长度为 m m m的旋转相当于没有变化。
- step 2：第一次将整个字符串翻转，得到字符串的逆序，它已经满足了左移的整体出现在了右边。
- step 3：第二次就将左边的 m − n m-n m−n个元素单独翻转，因为它虽然移到了左边，但是逆序了。
- step 4：第三次就将右边的 n n n个元素单独翻转，因此这部分也逆序了。
图示：
Java实现代码：
public class Solution {
public String LeftRotateString(String str,int n) {
//取余，因为每次长度为n的旋转数组相当于没有变化
if(str.isEmpty() || str.length() == 0)
return "";
int m = str.length();
n = n % m;
//第一次逆转全部元素
char[] s = str.toCharArray();
reverse(s, 0, m - 1);
//第二次只逆转开头m个
reverse(s, 0, m - n - 1);
//第三次只逆转结尾m个
reverse(s, m - n, m - 1);
return new String(s);
}
//反转函数
private void reverse(char[] s, int start, int end){
while(start < end){
swap(s, start++, end--);
}
}
//交换函数
private void swap(char[] s, int a, int b){
char temp = s[a];
s[a] = s[b];
s[b] = temp;
}
}
C++实现代码：
class Solution {
public:
string LeftRotateString(string str, int n) {
int m = str.length();
//特殊情况
if(m == 0)
return "";
//取余，因为每次长度为m的旋转相当于没有变化
n = n % m;
//第一次逆转全部数组元素
reverse(str.begin(), str.end());
//第二次只逆转开头m个
reverse(str.begin(), str.begin() + m - n);
//第三次只逆转结尾m个
reverse(str.begin() + m - n, str.end());
return str;
}
};
Python实现代码：
class Solution:
#反转函数
def reverse(self, s: List, start: int, end: int):
while start < end:
self.swap(s, start, end)
start += 1
end -= 1
#交换函数
def swap(self, s: List, a: int, b: int):
temp = s[a]
s[a] = s[b]
s[b] = temp
def LeftRotateString(self , str: str, n: int) -> str:
#取余，因为每次长度为n的旋转数组相当于没有变化
s = list(str)
m = len(s)
if m == 0:
return ""
n = n % m
#第一次逆转全部元素
self.reverse(s, 0, m - 1);
#第二次只逆转开头m个
self.reverse(s, 0, m - n - 1)
#第三次只逆转结尾m个
self.reverse(s, m - n, m - 1)
return ''.join(s)
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，三次reverse函数的复杂度都最坏为 O ( n ) O(n) O(n)
- 空间复杂度： O ( 1 ) O(1) O(1)，C++没有使用额外的辅助空间，java与Python借助了 O ( n ) O(n) O(n)的空间
方法二：遍历拼接（扩展思路）
思路：
既然循环左移是前面 n n n个字符平移到了最后，我们就可以分开加入字符串中，先挨个加入后面部分字符，然后再回过头加入前面的字符。
具体做法：
- step 1：因为 n n n可能大于字符串长度，因此需要对长度 m m m取余，因为每次长度为 m m m的旋转相当于没有变化。
- step 2：先遍历后 m − n m-n m−n个字符，依次加入待返回的字符串中。
- step 3：再遍历前 n n n个字符，依次加入待返回的字符串中。
Java实现代码：
import java.util.*;
public class Solution {
public String LeftRotateString(String str,int n) {
//取余，因为每次长度为n的旋转数组相当于没有变化
if(str.isEmpty() || str.length() == 0)
return "";
int m = str.length();
//取余，因为每次长度为m的旋转数组相当于没有变化
n = n % m;
StringBuilder res = new StringBuilder();
//先遍历后面的，放到前面
for(int i = n; i < m; i++)
res.append(str.charAt(i));
//再遍历前面的放到后面
for(int i = 0; i < n; i++)
res.append(str.charAt(i));
return res.toString();
}
}
C++实现代码：
class Solution {
public:
string LeftRotateString(string str, int n) {
int m = str.length();
//特殊情况
if(m == 0)
return "";
//取余，因为每次长度为m的旋转数组相当于没有变化
n = n % m;
string res = "";
//先遍历后面的，放到前面
for(int i = n; i < m; i++)
res += str[i];
//再遍历前面的放到后面
for(int i = 0; i < n; i++)
res += str[i];
return res;
}
};
Python实现代码：
class Solution:
def LeftRotateString(self , str: str, n: int) -> str:
m = len(str)
#特殊情况
if m == 0:
return ""
#取余，因为每次长度为m的旋转数组相当于没有变化
n = n % m
res = ""
#先遍历后面的，放到前面
for i in range(n, m):
res += str[i]
#再遍历前面的放到后面
for i in range(n):
res += str[i]
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为字符串的长度，两次遍历相当于遍历整个字符串
- 空间复杂度： O ( 1 ) O(1) O(1)，res属于返回必要空间，无额外辅助空间
题目主要信息：
- 给一个01矩阵，1代表是陆地，0代表海洋，如果两个1相邻，则这两个1属于同一个岛
- 只考虑上下左右为相邻
- 判断岛屿的个数
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：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最坏情况队列大小为长和宽的较小值
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
