剑指Offer：37 二叉树的序列化

20.5.6  最精简的写法

class Codec {
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()) {
            TreeNode* tmp = q.front();
            q.pop();
            if(tmp) {
                out << tmp->val <<" ";
                q.push(tmp->left);
                q.push(tmp->right);
            }
            else {
                out << "null ";
            }
        }
        return out.str();
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream input(data);
        string val;
        vector<TreeNode*> vec;

        //一段段字符串输入,存储到vec中
        while(input >> val) {
            if(val == "null") {
                vec.push_back(NULL);
            }
            else {
                vec.push_back(new TreeNode(stoi(val)));
            }
        }
        int j = 1;   //i每往后移动一位，j移动两位，j始终是当前i的左子下标
        for(int i = 0; j < vec.size(); i++) { // 肯定是j先到达边界，所以这里判断j < vec.size()
            if(vec[i] == NULL) continue;      // vec[i]为null时跳过
            if(j < vec.size()) vec[i]->left = vec[j++];   // 当前j位置为i的左子树
            if(j < vec.size()) vec[i]->right = vec[j++];  // 当前j位置为i的右子树
        }
        return vec[0];
    }
};

---

这道题是今天做的5道二叉树习题中最难的一道了，主要因为对C++/C中的几种字符串的操作不熟悉，花了很多时间理清楚语法基础：C++ 字符串与字符数组 详解 

序列化时的难点：对字符串 string 和 char* 的合理利用和相互转化

反序列化的难点：比序列化更难，从序列递归建树的过程：

遇到 '!' 分隔符就跳过，遇到 '#' 空节点就返回空节点，遇到数字串，如“......12345!......\0”中的 12345，转化为数字后建立节点。

再经过递归处理该节点的左右子节点，难点就在于，递归的输入 + 递归结束的条件：看代码和注释！

语法注意的点：反序列化时向后移动 str0 指针，不能直接 str0++，必须要一个固定的指针 str 指向 str0，由它来改变 str0 的值向后遍历序列。因为：递归时改变了str值使其指向后面的序列，因此要声明为char**（这里还是不是太明白，继续查资料）

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    char* Serialize(TreeNode *root) {    
        //char result[] = ""; //单引号是字符char，不带终止字符null('\0')
        if(!root) return nullptr;
        
        string s;
        SerializeCore(root, s);
        
        int length = s.length();
        char * ans = new char[length + 1]; //第一遍写就卡在了这一步,new很关键，要把数组保存下来！
        for(int i = 0; i < length; i ++) {
            ans[i] = s[i];
        }
        ans[length] = '\0';
        
        return ans;
    }
    
    void SerializeCore(TreeNode *root, string& str) {
        if(!root) { //空节点，加 #! 即可
            str += "#!";
            return;
        }
        str += to_string(root->val);
        str += "!";
        SerializeCore(root->left, str);
        SerializeCore(root->right, str);
    }
    
    
    TreeNode* Deserialize(char *str) {
        if(!str) return nullptr;
        
        return DeserializeCore(&str);
    }
    
    TreeNode* DeserializeCore(char** str) {
        if(!str) return nullptr;
        
        //先处理当前节点
        if(**str == '!') { //遇到了分隔符就向后移动一位
            (*str)++;
        }
        if(**str == '#') {
            (*str)++;      //遇到了空节点，返回nullptr指针，并将指针向后移动一位
            return nullptr;
        }
        //遇到数字先转化
        int num = 0;
        while(**str != '!' && **str != '\0') {
            num = num * 10 + (**str - '0');
            (*str)++;
        }
        //转化完一个数字，开始建立节点
        TreeNode* node = new TreeNode(num);
        //node -> val = num;
        
        //再处理当前节点的左右子树
        if(**str == '\0') {
            return nullptr; //如果字符串已经结束，就不需要再递归，结束递归
        }
        //如果字符串未结束，继续递归下去，用剩下节点构建当前节点的左子树、右子树
        //这里是个难点，一开始想不到递归输入的参数怎么写，以及递归终止条件！
        node -> left = DeserializeCore(str);
        node -> right = DeserializeCore(str);
        
        //最后返回当前节点
        return node;
    }
};

参考的芦苇的刷题笔记，和我的写法略不同，他在 # 之后没有加 ! 作为分离，而我加了这一项：

class Solution {
public:
    char* Serialize(TreeNode *root) {    
        if(!root){
            return NULL;
        }
        string str;
        SerializeCore(root, str);
        // 把str流中转换为字符串返回
        int length = str.length();
        char* res = new char[length+1];
        // 把str流中转换为字符串返回
        for(int i = 0; i < length; i++){
            res[i] = str[i];
        }
        res[length] = '\0';
        return res;
    }
    TreeNode* Deserialize(char *str) {
        if(!str){
            return NULL;
        }
        TreeNode* res = DeserializeCore(&str);
        return res;
    }
    void SerializeCore(TreeNode* root, string& str){
        // 如果指针为空，表示左子节点或右子节点为空，则在序列中用#表示
        if(!root){
            str += '#';
            return;
        }
        string tmp = to_string(root->val);
        str += tmp;
        // 加逗号，用于区分每个结点
        str += ',';
        SerializeCore(root->left, str);
        SerializeCore(root->right, str);
    }
    // 递归时改变了str值使其指向后面的序列，因此要声明为char**
    TreeNode* DeserializeCore(char** str){
        // 到达叶节点时，调用两次，都返回null，所以构建完毕，返回父节点的构建
        if(**str == '#'){
            (*str)++;
            return NULL;
        }
        // 因为整数是用字符串表示，一个字符表示一位，先进行转换
        int num = 0;
        while(**str != ',' && **str != '\0'){
            num = num * 10 + ((**str) - '0');
            (*str)++;
        }
        TreeNode* root = new TreeNode(num);
        if(**str == '\0'){
            return root;
        }
        else{
            (*str)++;
        }
        root->left = DeserializeCore(str);
        root->right = DeserializeCore(str);
        return root;
    }
};