leetcode 297 二叉树序列化与反序列化

序列化不困难，主要是序列化之后怎么能够反序列回来，所以需要在序列化的过程中加入空子树的指示符，以指示反序列化的结果。通过前序遍历的思路还是比较简单的，结果造成最大问题的是负数，在涉及负数的时候尤其要注意。

/**
 * 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.
    void generate(TreeNode* root,string& str)
    {
        if(!root)
        {
            str += "N,";
        }
        else
        {
            str += to_string(root->val) + ",";
            generate(root->left,str);
            generate(root->right,str);
        }
    }
    string serialize(TreeNode* root) 
    {
        string res;
        generate(root,res);
        return res;
    }

    // Decodes your encoded data to tree.
    TreeNode* rgenerate(list<string>& data)
    {
        if(data.empty())
        return NULL;
        if(data.front() == "N")
        {
            data.erase(data.begin());
            return NULL;
        }
        TreeNode* this_root = new TreeNode(stoi(data.front()));
        data.erase(data.begin());
        this_root->left = rgenerate(data);
        this_root->right = rgenerate(data);
        return this_root;
    }
    TreeNode* deserialize(string data) 
    {
        list<string> list_data;
        string str;
        for(auto& temp:data)
        {
            if(temp == ',')
            {
                list_data.push_back(str);
                str.clear();
            }
            else
            {
                str.push_back(temp);
            }
        }

        return rgenerate(list_data);
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));

bfs的方法，还是用到了队列，与之前二叉树中的方法是类似的，写起来很舒服，贴代码

/**
 * 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) 
    {
        queue<TreeNode*> Node_que;
        string res;
        Node_que.push(root);
        while(!Node_que.empty())
        {
            TreeNode* temp = Node_que.front();
            Node_que.pop();
            if(!temp)
            {
                res += ("N,");
            }
            else
            {
                res += (to_string(temp->val)+",");
                Node_que.push(temp->left);
                Node_que.push(temp->right);
            }
        }
        return res;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) 
    {
        vector<string> str_vec;
        string str;
        for(auto& temp:data)
        {
            if(temp == ',')
            {
                str_vec.push_back(str);
                str.clear();
            }
            else
            {
                str.push_back(temp);
            }
            
        }
        int n = str_vec.size();
        if(n == 1)
        return NULL;
        TreeNode* root = new TreeNode(stoi(str_vec[0]));
        queue<TreeNode*> Node_que;
        Node_que.push(root);
        int pos = 0;
        while(!Node_que.empty())
        {
            TreeNode* Node_temp = Node_que.front();
            Node_que.pop();
            if(str_vec[pos+1] != "N" && pos+1 < n)
            {
                TreeNode* left = new TreeNode(stoi(str_vec[pos+1]));
                Node_temp->left = left;
                Node_que.push(left);
            }
            if(str_vec[pos+2] != "N" && pos+2 < n)
            {
                TreeNode* right = new TreeNode(stoi(str_vec[pos+2]));
                Node_temp->right = right;
                Node_que.push(right);
            }
            pos+=2;
        } 
        return root;       
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(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:
    string Res;
    vector<string> tempStr;
    int pointer = 0;
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) 
    {
        preOrder(root);
        return Res;
    }
    void preOrder(TreeNode* root)
    {
        if(!root)
        {
            Res+='N,';
            return;
        }
        else
        {
            Res+=(to_string(root->val)+",");
            preOrder(root->left);
            preOrder(root->right);
            return;
        }
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) 
    {
        string tempString = data;
        while(tempString.length())
        {
            int pos = tempString.find(',');
            tempStr.push_back(tempString.substr(0,pos));
            tempString = tempString.substr(pos+1);            
        }
        return preOrderReverse(tempStr[pointer]);
    }
    TreeNode* preOrderReverse(string t)
    {
        if(t == "N")
        {
            pointer++;
            return NULL;
        }
        else
        {
            TreeNode* node = new TreeNode(atoi(t.c_str()));
            pointer++;
            node->left = preOrderReverse(tempStr[pointer]);
            node->right = preOrderReverse(tempStr[pointer]);
            return node;
        }
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));