leetcode 449 序列化和反序列化二叉搜索

问题：
序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。
设计一个算法来序列化和反序列化二叉搜索树。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。
编码的字符串应尽可能紧凑。
注意：不要使用类成员/全局/静态变量来存储状态。 你的序列化和反序列化算法应该是无状态的。
解释：
给定一个二叉查找树，实现对该二叉查找树编码与解码功能。编码即将该二叉查找树转为字符串，解码即将字符串转为二叉查找树。不限制使用何种编码算法，只需保证当对二叉查找树调用编码功能后可再调用解码功能将其复原。

对二叉查找树进行先序遍历，将遍历得到的结果按顺序重新构造为一颗新的二叉查找树，新的二叉树与原二叉查找树完全一样

二叉查找树编码为字符串：
将二叉查找树前序遍历，遍历时将整型的数据转为字符串，并将这些字符串数据进行连接，连接时使用特殊符号分割
字符串解码为二叉查找树：
将字符串按照编码时的分隔符“#”，将各个数字逐个拆分出来，将第一个数字构建为二叉查找树的根节点，后面各个数字构建出的节点按解析时的顺序插入根节点中，返回根节点，即完成解码的工作。
整数转字符串(编码阶段)：
利用对整数10取余，可以逐个循环的将一个整型从低位到高位拆分出来，在这个过程中每取出一个最低位，就将该数字除以10。每拆分出一个字符串，就将该字符串添加到string中，直到该数字为0结束。最后将string进行反转，就完成了整型转字符串

void change_into_to_string(int val, std::string &str_val){
     
        std::string tmp;
        while(val){
     
            tmp += val % 10 + '0';
            val = val / 10;
        }
        for (int i = tmp.length() - 1; i >= 0; i--){
     
            str_val += tmp[i];        //逆序将字符串添加到tmp的尾部
        }
        str_val += '#';
    }

字符串拆分为整数(解码阶段)：

#include 
#include 
int main() {
     
	std::string str = "123#456#10000#1#";
	int val = 0;
	for (int i = 0; i < str.length(); i++) {
     
		if (str[i] == '#') {
     
			printf("val = %d\n", val);
		}
		else {
     
			val = val * 10 + str[i] - '0';
		}
	}
	return 0;
}

完整代码如下：

/**
 * 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) {
     
        std::string data;
        BST_preorder(root, data);   //将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;
        for (int i = 0; i < data.length(); i++){
     
            if (data[i] == '#'){
     
                node_vec.push_back(new TreeNode(val));
                val = 0;
            }
            else{
     
                val = val * 10 + data[i] - '0';
            }
        }
        for (int i = 1; i < node_vec.size(); i++){
     
            BST_insert(node_vec[0],node_vec[i]);
        }
        return node_vec[0];       //return根节点的地址
    }
private:
    void change_into_to_string(int val, std::string &str_val){
        //数字转字符
        std::string tmp;
        while(val){
     
            tmp += val % 10 + '0';
            val = val / 10;
        }
        for (int i = tmp.length() - 1; i >= 0; i--){
     
            str_val += tmp[i];        //逆序将字符串添加到tmp的尾部
        }
        str_val += '#';
    }
    void BST_preorder(TreeNode *node, std::string &data){
         //前序遍历将树转化成字符串
        if (!node){
     
            return;
        }
        std::string str_val;
        change_into_to_string(node->val, str_val);
        data += str_val;
        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;
		    }
	    }
    }
};