LeetCode 449 序列化和反序列化二叉搜索树[二叉树 序列化 前序 中序 后序] HERODING的LeetCode之路

解题思路：
如果做过297. 二叉树的序列化与反序列化这道题的话，那么本题无需更改，直接沿用即可（本题只是在297基础上多了一个二叉搜索树的条件），297的思想是将整个二叉树层次遍历序列化成字符串（包括null也序列化），在反序列化中转化为数组形式（根据‘，’划分），然后根据根与左右节点的关系（2index+1和2index+2，index是根在数组中下标），重构二叉树，如果还不清楚可以看我的这篇博客，代码如下：

/**
 * 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) {
        string res;
        // 如果根为空
        if(root == nullptr) {
            return res;
        } 
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()) {
            TreeNode* demo = q.front();
            q.pop();
            if(demo != nullptr) {
                res += to_string(demo -> val) + ",";
                q.push(demo -> left);
                q.push(demo -> right);
            } else {
                res += "null,";
            }
        }
        return res;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data == "") {
            return nullptr;
        }
        vector<string> vals;
        // 分割字符串
        string s;
        for(int i = 0; i < data.size(); i ++) {
            if(data[i] == ',') {
                vals.push_back(s);
                s = "";
            } else {
                s += data[i];
            }
        }
        TreeNode* root = new TreeNode(atoi(vals[0].c_str()));
        queue<TreeNode*> q;
        q.push(root);
        // 标记当前根的位置
        int i = 0;
        while(!q.empty()) {
            TreeNode* demo = q.front();
            q.pop();
            // 有左节点
            if(vals[i * 2 + 1] != "null") {
                demo -> left = new TreeNode(atoi(vals[i * 2 + 1].c_str()));
                q.push(demo -> left);
            }
            // 有右节点
            if(vals[i * 2 + 2] != "null") {
                demo -> right = new TreeNode(atoi(vals[i * 2 + 2].c_str()));
                q.push(demo -> right);
            }
            i ++;
        }
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

但是题目既然给了搜索二叉树这个条件，那么最好能利用上，搜索二叉树的中序遍历就是从小到大的排序，所以只要获得前序遍历或者后序遍历，就可以重构二叉树，首先是前序遍历的方法，根据搜索二叉树获得前序遍历，然后将前序遍历结果转换为string输出，反序列化接收输出并转化回数组，排序后获得中序遍历结果，根据前序遍历获得根，中序遍历知左右，构建出搜索二叉树，注意，为了方便左右递归（根据中序遍历中根左边为左子树，右边为右子树），用哈希表记录下中序遍历中数和index的关系，代码如下：

/**
 * 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 {
private:
    unordered_map<int, int> mp;
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        vector<int> pre;
        dfs(root, pre);
        string data;
        for(int i = 0; i < pre.size(); i ++) {
            data += to_string(pre[i]) + ',';
        }
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        // 获取前序遍历和中序遍历
        vector<int> pre;
        string s;
        for(int i = 0; i < data.size(); i ++) {
            if(data[i] == ',') {
                pre.emplace_back(atoi(s.c_str()));
                s = "";
            } else {
                s += data[i];
            }
        }
        vector<int> in = pre;
        sort(in.begin(), in.end());
        int n = pre.size();
        // 存储中序遍历下标
        for(int i = 0; i < n; i ++) {
            mp[in[i]] = i;
        }
        // idx指向根节点下标
        int idx = 0;
        // 构建树
        return build(in, pre, 0, n - 1, idx);
    }

    // 构建树
    TreeNode* build(vector<int>& in, vector<int>& pre, int l, int r, int& idx) {
        if(l > r) return nullptr;
        // 区间只有一个元素，直接返回该元素
        if(l == r) {
            idx ++;
            return new TreeNode(in[l]);
        }
        int root = pre[idx ++];
        int index = mp[root];
        TreeNode* tree = new TreeNode(root);
        tree->left = build(in, pre, l, index - 1, idx);
        tree->right = build(in, pre, index + 1, r, idx);
        return tree;
    }

    // 前序遍历
    void dfs(TreeNode* root, vector<int>& pre) {
        if(root == nullptr) return;
        pre.emplace_back(root -> val);
        dfs(root->left, pre);
        dfs(root->right, pre); 
    }
};

// Your Codec object will be instantiated and called as such:
// Codec* ser = new Codec();
// Codec* deser = new Codec();
// string tree = ser->serialize(root);
// TreeNode* ans = deser->deserialize(tree);
// return ans;

后序遍历也是同样的操作，只不过根在最后，简单修改即可，代码如下：

/**
 * 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 {
private:
    unordered_map<int, int> mp;
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        vector<int> post;
        dfs(root, post);
        string data;
        for(int i = 0; i < post.size(); i ++) {
            data += to_string(post[i]) + ',';
        }        
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        // 获取后序遍历和中序遍历
        vector<int> post;
        string s;
        for(int i = 0; i < data.size(); i ++) {
            if(data[i] == ',') {
                post.emplace_back(atoi(s.c_str()));
                s = "";
            } else {
                s += data[i];
            }
        }
        vector<int> in = post;
        sort(in.begin(), in.end());
        int n = in.size();
        // 存储中序遍历下标
        for(int i = 0; i < n; i ++) {
            mp[in[i]] = i;
        }
        // idx指向根节点下标
        int idx = n - 1;
        // 构建树
        return build(in, post, 0, n - 1, idx);
    }

    // 构建树
    TreeNode* build(vector<int>& in, vector<int>& post, int l, int r, int& idx) {
        if(l > r) return nullptr;
        // 区间只有一个元素，直接返回该元素
        if(l == r) {
            idx --;
            return new TreeNode(in[l]);
        }
        int root = post[idx --];
        int index = mp[root];
        TreeNode* tree = new TreeNode(root);
        tree->right = build(in, post, index + 1, r, idx);
        tree->left = build(in, post, l, index - 1, idx);
        return tree;
    }

    // 后序遍历
    void dfs(TreeNode* root, vector<int>& post) {
        if(root == nullptr) return;
        dfs(root->left, post);
        dfs(root->right, post);
        post.emplace_back(root -> val);
    }
};

// Your Codec object will be instantiated and called as such:
// Codec* ser = new Codec();
// Codec* deser = new Codec();
// string tree = ser->serialize(root);
// TreeNode* ans = deser->deserialize(tree);
// return ans;