经典算法序列化和反序列化二叉搜索树

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

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

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

注意：不要使用类成员/全局/静态变量来存储状态。 你的序列化和反序列化算法应该是无状态的。

2、我的代码
没写出来
3、网上好的解法
序列化一个二叉树表示：

• 对树的结构编码
• 对树节点的值编码
• 利用分隔符分隔字符串中的值

方法一：后序遍历优化树结构的空间

算法：

二叉搜索树能只够通过前序序列或后序序列构造，是因为以下两个因素：

• 二叉树可以通过前序序列、后序序列和中序序列构造。
• 二叉搜索树的中序序列是递增排序的序列，inorder = sorted(preorder)。

说明我们只需要知道了前序序列或后序序列，便可推算出中序序列，可以通过排序获得。
序列化可以很容易的实现，但是对于反序列化我们选择后续遍历会更好。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {
    public StringBuilder postorder(TreeNode root, StringBuilder sb) {
        if (root == null) return sb;
        postorder(root.left, sb);
        postorder(root.right, sb);
        sb.append(root.val);
        sb.append(' ');
        return sb;
    }
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
       StringBuilder sb = postorder(root, new StringBuilder());
       if(sb.length() > 1)
            sb.deleteCharAt(sb.length() - 1);
        return sb.toString(); 
    }

    public TreeNode helper(Integer lower, Integer upper, ArrayDeque<Integer> nums) {
        if (nums.isEmpty()) return null;
        int val = nums.getLast();
        if (val < lower || val > upper) return null;

        nums.removeLast();
        TreeNode root = new TreeNode(val);
        root.right = helper(val, upper, nums);
        root.left = helper(lower, val, nums);
        return root;
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.isEmpty()) return null;
        ArrayDeque<Integer> nums = new ArrayDeque<Integer>();
        for (String s : data.split("\\s+"))
            nums.add(Integer.valueOf(s));
        return helper(Integer.MIN_VALUE, Integer.MAX_VALUE, nums); 
    }
}

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

4、自己代码可以优化的地方

5、优化代码至简无可简

/**
 * 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 str;
        queue<TreeNode*> nodeTree;
        nodeTree.push(root);

        while(!nodeTree.empty()){
            int count = nodeTree.size();
            while(count--){
                TreeNode* node = nodeTree.front();
                nodeTree.pop();
                if(node == nullptr){
                    str += "#";
                }else{
                    str += to_string(node->val) + "!";
                    nodeTree.push(node->left);
                    nodeTree.push(node->right);
                }
            }
        };
        
        return str;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.empty())    return NULL;
        int i =0, j=0;
        while(j<data.size() && data[++j]!='!') ;    // [i, j) 存储节点
        TreeNode* head = new TreeNode(stoi(data.substr(i, j-i)) );
        
        queue<TreeNode*> queue;
        queue.push(head);
        
        while(i < data.size()){
            TreeNode* node = queue.front();
            queue.pop();
            if(node == NULL)    continue;
            // 左节点
            i = ++j;
            if(i >= data.size())    break;
            if(data[i] == '#')
                node->left = nullptr;
            else{
                while(j<data.size() && data[++j] != '!');
                node->left = new TreeNode(stoi(data.substr(i, j-i)) );
            }
            queue.push(node->left);
            // 右节点
            i = ++j;
            if(i >= data.size())    break;
            if(data[i] == '#')
                node->right = nullptr;
            else{
                while(j<data.size() && data[++j] != '!');
                node->right = new TreeNode(stoi(data.substr(i, j-i)) );
            }
            queue.push(node->right);
        }
        
        return head;
    }
};

6、我的思考