【JZ37 序列化二叉树】

描述

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。

二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）

二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，可以根据层序遍历的方案序列化，如下图:

层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}“，再能够调用反序列化(Deserialize)将”{1,2,3,#,#,6,7}"构造成如上的二叉树。

当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。

数据范围：节点数 n 100，树上每个节点的值满足 0 ≤ val ≤ 150
要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)

示例1

输入：{1,2,3,#,#,6,7}

返回值：{1,2,3,#,#,6,7}

说明：如题面图   

示例2

输入：{8,6,10,5,7,9,11}

返回值：{8,6,10,5,7,9,11}

方法一：先序遍历实现

• 假设序列化的结果为字符串 str, 初始str = “”.根据要求，遇到nullptr节点，str += “#” 遇到非空节点，str += “val” + “!”; 假设val为3， 就是 str += “3!”
• 反序列化的结果，就是根据先序遍历，再重建二叉树即可

代码

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);
    }
};

运行时间：3ms
超过37.20% 用C++提交的代码
占用内存：604KB
超过16.66%用C++提交的代码

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

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;
    }
};

运行时间：5ms
超过3.41% 用C++提交的代码
占用内存：560KB
超过22.71%用C++提交的代码