剑指 Offer II 048. 序列化与反序列化二叉树

题目

力扣

思路一 BFS

序列化：逐行把数据放入队列中，如果节点不为空，就把数据转化成string，并加上分隔符放入结果字符串中，再push左右节点进队列；如果节点为空，就放入空的标识符“#”。

反序列化：先把字符串由分隔符分隔，初始时把第一个节点放入队列，然后逐渐从队列中取出节点。定义一个cursor标识字符串列表中的数据取到了哪里，一个节点的左右孩子一定是连续的。为出队的节点添加左右孩子，并把左右孩子放入队列中。

代码一

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        if(root == nullptr) return "";
        string ans = "";
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            auto cur = q.front();
            q.pop();
            if(cur){
                ans += to_string(cur->val) + "*";
                q.push(cur->left);
                q.push(cur->right);
            }else
                ans += "#*";
        }
        return ans;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.size() == 0) return nullptr;
        vector<string> str = split(data,'*');
        TreeNode* root = new TreeNode(stoi(str[0]));
        int n = str.size(), cursor = 1;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            auto cur = q.front();
            q.pop();
            if(cursor < n && str[cursor] != "#"){
                TreeNode* left = new TreeNode(stoi(str[cursor]));
                cur->left = left;
                q.push(left);
            }
            cursor++;
            if(cursor < n && str[cursor] != "#"){
                TreeNode* right = new TreeNode(stoi(str[cursor]));
                cur->right = right;
                q.push(right);
            }
            cursor++;
        }
        return root;
    }

    vector<string> split(string& s, char c){
        vector<string> ans;
        int n = s.size();
        int left = -1, right = 0;
        while(right < n){
            if(s[right] == '*'){
                ans.push_back(s.substr(++left, right - left));
                left = right;
            }
            right++;
        }
        return ans;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));

思路二 DFS

把BFS遍历方式换成DFS，序列化和反序列化都用递归方式实现。反序列化顺序是先根节点，再左子树，后右子树。

代码二

class Codec {
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        if(root == nullptr) return "#*";
        return to_string(root->val)+"*"+serialize(root->left)+serialize(root->right);
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        list<string> strlist = split(data,'*');
        return buildTree(strlist);
    }

    TreeNode* buildTree(list<string> &strlist){
        string cur = strlist.front();
        strlist.pop_front();
        if(cur == "#")
            return nullptr;
        TreeNode* node = new TreeNode(stoi(cur));
        node->left = buildTree(strlist);
        node->right = buildTree(strlist);
        return node;
    }

    list<string> split(string& s, char c){
        list<string> ans;
        int n = s.size();
        int left = -1, right = 0;
        while(right < n){
            if(s[right] == c){
                ans.push_back(s.substr(++left, right - left));
                left = right;
            }
            right++;
        }
        return ans;
    }
};