leetcode449 序列化和反序列化二叉搜索树 中等

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

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

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

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

思路

序列化：将二叉树转换成字符串形式
反序列化：将字符串形式转换成二叉树

二叉搜索树也是排序树，根节点大于左节点，根节点小于右节点。

我们通过前序遍历将二叉搜索树转换为字符串，再通过遍历的方式转换为二叉搜索树的形式，即为树的重建。
*这里说明如果是后序和中序遍历是不能恢复二叉树的
前序：8，3，1，6，10，15
后序：1，6，3，15，10，8
中序：1，3，6，8，10，15

重建的话，后序中序都会以1为根节点，此时二叉树会偏向右边

所以，

1、序列化：

前序遍历，并将值转为字符串，以‘#’为分隔符

2、反序列化：

在字符串中提取数值，遇到‘#’就new新节点，并进行二叉树的递归插入

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
void change_int_to_string(int val, std::string &str_val){
     
    std::string tmp;
    while(val){
     //val每次循环都/10，因此循环val
        tmp += val % 10 + '0';//在字符0上作偏移
        val = val / 10;
    }//遍历val，每次将val个位转换为字符，添加到tmp尾部
    for(int i = tmp.length() - 1; i >= 0; i--){
     
        str_val += tmp[i];
    }//逆序
    str_val += '#';//转换每个数后加一个#
}

void BST_preorder(TreeNode *node, std::string &data){
     
    if(!node){
     
        return;
    } //前序遍历递归跳出
    std::string str_val;
    change_int_to_string(node->val, str_val);
    data += str_val;//将每个节点转换为字符然后添加到data
    BST_preorder(node->left, data);
    BST_preorder(node->right, data);
}

void BST_insert(TreeNode *node, TreeNode *insert_node){
     //用来对于一个根，插入元素
	if (insert_node->val < node->val){
     //新元素小于根
		if (node->left){
     //如果有左子树，递归插入
			BST_insert(node->left, insert_node);
		}
		else{
     //无左子树，插在左边
			node->left = insert_node;
		}
	}
	else{
     //否则新元素大于等于根
		if (node->right){
     //如果有右子树，递归插入
			BST_insert(node->right, insert_node);
		}
		else{
     //否则插在右
			node->right = insert_node;
		}
	}
}

class Codec {
     
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
     
        std::string data;//解码到data
        BST_preorder(root, data);
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
     
        if(data.length() == 0){
     
            return NULL;
        }//这是处理特殊情况，空树
        std::vector<TreeNode *> node_vec;
        int val = 0;//初始化node数组和val值
        for(int i = 0; i < data.length(); i++){
     //循环data提取所有节点值
            if(data[i] == '#'){
     //遇到#说明已经提取好了一个节点
                node_vec.push_back(new TreeNode(val));
                //这里不用delete，在类外delete析构即可，因为有root
                val = 0;//node数组push并且val清0用于下次提取
            }
            else{
     
                val = val * 10 + data[i] - '0';//否则当前继续计算当前数字值
            }
        }
        for(int i = 1; i < node_vec.size(); i++){
     
            //还原二叉排序树，这里注意从1开始因为用到BST_insert
            BST_insert(node_vec[0], node_vec[i]);
        }
        return node_vec[0];
    }
};

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