题目## 题目
题目主要信息：
- 序列化二叉树即找一种顺序存储二叉树的节点，并以相同的方式能够读取序列重新构建。
- 换种说法，就是遍历二叉树，记录每个节点，再以同样的方式遍历就可以还原二叉树。
- 遍历的方法有四种：前序遍历、中序遍历、后序遍历、层次遍历，理论上只要以相同的方式序列化或者反序列化，都可以解题。
举一反三：
学习完本题的思路你可以解决如下题目：
方法：前序遍历（推荐使用）
知识点：二叉树递归
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
而二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。
思路：
序列化即将二叉树的节点值取出，放入一个字符串中，我们可以按照前序遍历的思路，遍历二叉树每个节点，并将节点值存储在字符串中，我们用‘#’表示空节点，用‘!'表示节点与节点之间的分割。
反序列化即根据给定的字符串，将二叉树重建，因为字符串中的顺序是前序遍历，因此我们重建的时候也是前序遍历，即可还原。
具体做法：
- 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属于返回必要空间，无额外辅助空间
扫一扫
464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
