【每日一题】力扣：序列化和反序列化二叉搜索树【值得一看】

博客主页：Skylar Lin
望本文能够给您带来一定的帮助，如果有错误的地方敬请斧正！
新人博主🧑，希望多多支持🍺，还有好多库存和大家分享🎁。
转载需注明出处和原作🌹。

序列化和反序列化二叉搜索树

序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。

设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。

编码的字符串应尽可能紧凑。

示例 1：
输入：root = [2,1,3]
输出：[2,1,3]

示例 2：
输入：root = []
输出：[]

解题思路

这道题的难点在于如何还原二叉树的模样，也就是反序列这一步。

而我们知道，想要了解二叉树的具体模样，可以由它的两种遍历方式推测出，这便是解题的关键。

那么怎么获得这两种遍历方式呢？

其一，可通过序列化这一步骤，获得二叉树的前序遍历（或后序遍历）字符串；

其二，由二叉搜索树的特性，即：其中序遍历为一个升序数组，我们就获得了第二种遍历方式。

在本题中，序列化部分我采用了后序遍历的方式，并用空格加以区分节点的值。

那么，获得两种遍历方式之后，如何反序列化呢？

思路是：用递归不断构造当前节点的左右孩子。

• 当前节点通过后序遍历数组确定；
• 左右孩子由中序遍历数组确定；
• 同时不断更新两个数组。

这一办法不懂的话可以做一下：从中序和后序遍历序列构造二叉树

/**
 * 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 data = "";
        stack<TreeNode*> st;
        if(root) st.push(root);
        while(!st.empty()){
            TreeNode *node = st.top();
            st.pop();
            if(node){
                st.push(node);
                st.push(nullptr);
                
                if(node -> right) st.push(node -> right);
                if(node -> left) st.push(node -> left);
            }
            else{
            	node = st.top();
                st.pop();
                data += to_string(node -> val) + " ";
            }
    	}
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(!data.size()){
            return nullptr;
        }
        // 后序遍历数组
        vector<int> vt;
        int val = 0;
        for(int i = 0; i < data.length(); ++i){
            if(data[i] == ' '){
                vt.push_back(val);
                val = 0;
            }
            else{
            	val = val * 10 + (data[i] - '0');
            }
        }
        // 中序遍历数组
        vector<int> vt2 = vt;
        sort(vt2.begin(), vt2.end());
        
        TreeNode *root = buildtree(vt, vt2);
        
        return root;
    }
    
    TreeNode* buildtree(vector<int> vt, vector<int> vt2){
        if(!vt.size()) return nullptr;
        
        TreeNode *root = new TreeNode(vt[vt.size() - 1]);
        
        int dest;   // 表示当前根节点在中序遍历中的下标位置
        for(dest = 0; dest < vt2.size(); dest++){
            if(vt2[dest] == vt[vt.size() - 1]) break;
        }
        // 切割中序遍历数组
        vector<int> front_vt2(vt2.begin(), vt2.begin() + dest);
        vector<int> end_vt2(vt2.begin() + dest + 1, vt2.end());
        // 切割后序遍历数组
        vector<int> front_vt(vt.begin(), vt.begin() + dest);
        vector<int> end_vt(vt.begin() + dest, vt.end() - 1);
        
        root -> left = buildtree(front_vt, front_vt2);
        root -> right = buildtree(end_vt, end_vt2);
        
        return root;
    }
};