LintCode-7-二叉树的序列化和反序列化

二叉树的序列化和反序列化

设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。

如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符串反序列化为原来的树结构。

注意事项

There is no limit of how you deserialize or serialize a binary tree, LintCode will take your output of serialize as the input of deserialize, it won't check the result of serialize.

样例

给出一个测试数据样例， 二叉树{3,9,20,#,#,15,7}，表示如下的树结构：



我们的数据是进行BFS遍历得到的。当你测试结果wrong answer时，你可以作为输入调试你的代码。

你可以采用其他的方法进行序列化和反序列化。

标签

二叉树 微软 雅虎

code

/**
* Definition of TreeNode:
* class TreeNode {
* public:
*     int val;
*     TreeNode *left, *right;
*     TreeNode(int val) {
*         this->val = val;
*         this->left = this->right = NULL;
*     }
* }
*/
class Solution {
public:

/**
* http://www.lintcode.com/zh-cn/ladder/6/-第8章-7-二叉树的序列化和反序列化 * 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.
*/
string serialize(TreeNode *root) {
// write your code here

string result = "";
TreeNode *node=root;

if(node == NULL)
return result;

preorderTraversal(node, result);

return result;
}

void preorderTraversal(TreeNode *root, string &result) {

if(root == NULL) {
result += "#,";
}
else {
char temp[20];
sprintf(temp, "%d,", root->val);
result += temp;
preorderTraversal(root->left, result);
preorderTraversal(root->right, result);
}
}

/**
* 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
int size = data.size(),i=0;
if(size == 0)
return NULL;

TreeNode *root;
vector<string> treeArray = split(data, ",");
depreorderTraversal(root, treeArray, i, treeArray.size());

return root;
}

void depreorderTraversal(TreeNode *&root, vector<string> &treeArray, int &i, const int size) {
if(i < size) {
if(treeArray[i].compare("#") == 0) {
root = NULL;
i++;
}
else {
root = (TreeNode*)malloc(sizeof(TreeNode));
root->val = atoi(treeArray[i].c_str());
i++;
depreorderTraversal(root->left,treeArray, i, size);
depreorderTraversal(root->right,treeArray, i, size);
}
}
}

vector<string> split(const string &s, const string &seperator){
vector<string> result;
typedef string::size_type string_size;
string_size i = 0;

while(i != s.size()){
//找到字符串中首个不等于分隔符的字母；
int flag = 0;
while(i != s.size() && flag == 0){
flag = 1;
for(string_size x = 0; x < seperator.size(); ++x)
if(s[i] == seperator[x]){
++i;
flag = 0;
break;
}
}

//找到又一个分隔符，将两个分隔符之间的字符串取出；
flag = 0;
string_size j = i;
while(j != s.size() && flag == 0){
for(string_size x = 0; x < seperator.size(); ++x)
if(s[j] == seperator[x]){
flag = 1;
break;
}
if(flag == 0)
++j;
}
if(i != j){
result.push_back(s.substr(i, j-i));
i = j;
}
}
return result;
}
};