题目描述
设计一个算法，并编写代码来序列化和反序列化二叉树。
将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。
如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符串反序列化为原来的树结构。
样例1
输入：{3,9,20,#,#,15,7}
输出：{3,9,20,#,#,15,7}
解释：
二叉树 {3,9,20,#,#,15,7}，表示如下的树结构：
3
/ \
9 20
/ \
15 7
它将被序列化为 {3,9,20,#,#,15,7}
样例2
输入：{1,2,3}
输出：{1,2,3}
解释：
二叉树 {1,2,3}，表示如下的树结构：
1
/ \
2 3
它将被序列化为 {1,2,3}
java题解
serialize()采用bfs，对当前二叉树搜索，遍历vector，将当前节点左右儿子依次存入vector，空节点需要删去。
deserialize()首先切割字符串，然后用isLeftChild标记是当前是左右儿子，数字转化为字符串，存为队列首节点的左右儿子。
class Solution {
/**
* This method will be invoked first, you should design your own algorithm
* to serialize a binary tree which denote by a root node to a string which
* can be easily deserialized by your own "deserialize" method later.
*/
public String serialize(TreeNode root) {
if (root == null) {
return "{}";
}
ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
queue.add(root);
for (int i = 0; i < queue.size(); i++) {
TreeNode node = queue.get(i);
if (node == null) {
continue;
}
queue.add(node.left);
queue.add(node.right);
}
while (queue.get(queue.size() - 1) == null) {
queue.remove(queue.size() - 1);
}
StringBuilder sb = new StringBuilder();
sb.append("{");
sb.append(queue.get(0).val);
for (int i = 1; i < queue.size(); i++) {
if (queue.get(i) == null) {
sb.append(",#");
} else {
sb.append(",");
sb.append(queue.get(i).val);
}
}
sb.append("}");
return sb.toString();
}
/**
* This method will be invoked second, the argument data is what exactly
* you serialized at method "serialize", that means the data is not given by
* system, it's given by your own serialize method. So the format of data is
* designed by yourself, and deserialize it here as you serialize it in
* "serialize" method.
*/
public TreeNode deserialize(String data) {
if (data.equals("{}")) {
return null;
}
String[] vals = data.substring(1, data.length() - 1).split(",");
ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
queue.add(root);
int index = 0;
boolean isLeftChild = true;
for (int i = 1; i < vals.length; i++) {
if (!vals[i].equals("#")) {
TreeNode node = new TreeNode(Integer.parseInt(vals[i]));
if (isLeftChild) {
queue.get(index).left = node;
} else {
queue.get(index).right = node;
}
queue.add(node);
}
if (!isLeftChild) {
index++;
}
isLeftChild = !isLeftChild;
}
return root;
}
}
C++题解
serialize()采用bfs，对当前二叉树搜索，遍历vector，将当前节点左右儿子依次存入vector，空节点需要删去。
deserialize()首先切割字符串，然后用isLeftChild标记是当前是左右儿子，数字转化为字符串，存为队列首节点的左右儿子。
class Solution {
public:
/**
* This method will be invoked first, you should design your own algorithm
* to serialize a binary tree which denote by a root node to a string which
* can be easily deserialized by your own "deserialize" method later.
*/
vector<string> split(const string &str, string delim) {
vector<string> results;
int lastIndex = 0, index;
while ((index = str.find(delim, lastIndex)) != string::npos) {
results.push_back(str.substr(lastIndex, index - lastIndex));
lastIndex = index + delim.length();
}
if (lastIndex != str.length()) {
results.push_back(str.substr(lastIndex, str.length() - lastIndex));
}
return results;
}
string serialize(TreeNode *root) {
if (root == NULL) {
return "{}";
}
vector<TreeNode *> q;
q.push_back(root);
for(int i = 0; i < q.size(); i++) {
TreeNode * node = q[i];
if (node == NULL) {
continue;
}
q.push_back(node->left);
q.push_back(node->right);
}
while (q[q.size() - 1] == NULL) {
q.pop_back();
}
string sb="";
sb += "{";
sb += to_string(q[0]->val);
for (int i = 1; i < q.size(); i++) {
if (q[i] == NULL) {
sb += (",#");
}
else {
sb += ",";
sb += to_string(q[i]->val);
}
}
sb += "}";
return sb;
}
/**
* This method will be invoked second, the argument data is what exactly
* you serialized at method "serialize", that means the data is not given by
* system, it's given by your own serialize method. So the format of data is
* designed by yourself, and deserialize it here as you serialize it in
* "serialize" method.
*/
TreeNode * deserialize(string &data) {
// write your code here
if (data == "{}") return NULL;
vector<string> vals = split(data.substr(1, data.size() - 2), ",");
TreeNode *root = new TreeNode(atoi(vals[0].c_str()));
queue<TreeNode *> Q;
Q.push(root);
bool isLeftChild= true;
for (int i = 1; i < vals.size(); i++) {
if (vals[i] != "#") {
TreeNode *node = new TreeNode(atoi(vals[i].c_str()));
if (isLeftChild) Q.front()->left = node;
else Q.front()->right = node;
Q.push(node);
}
if (!isLeftChild) {
Q.pop();
}
isLeftChild = !isLeftChild;
}
return root;
}
};
python题解
使用 BFS 的方法来 serialize
from collections import deque
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
self.val = val
self.left, self.right = None, None
"""
class Solution:
"""
@param root: An object of TreeNode, denote the root of the binary tree.
This method will be invoked first, you should design your own algorithm
to serialize a binary tree which denote by a root node to a string which
can be easily deserialized by your own "deserialize" method later.
"""
def serialize(self, root):
if root is None:
return ""
# use bfs to serialize the tree
queue = deque([root])
bfs_order = []
while queue:
node = queue.popleft()
bfs_order.append(str(node.val) if node else '#')
if node:
queue.append(node.left)
queue.append(node.right)
return ' '.join(bfs_order)
"""
@param data: A string serialized by your serialize method.
This method will be invoked second, the argument data is what exactly
you serialized at method "serialize", that means the data is not given by
system, it's given by your own serialize method. So the format of data is
designed by yourself, and deserialize it here as you serialize it in
"serialize" method.
"""
def deserialize(self, data):
# None or ""
if not data:
return None
bfs_order = [
TreeNode(int(val)) if val != '#' else None
for val in data.split()
]
root = bfs_order[0]
fast_index = 1
nodes, slow_index = [root], 0
while slow_index < len(nodes):
node = nodes[slow_index]
slow_index += 1
node.left = bfs_order[fast_index]
node.right = bfs_order[fast_index + 1]
fast_index += 2
if node.left:
nodes.append(node.left)
if node.right:
nodes.append(node.right)
return root
