297. Serialize and Deserialize Binary Tree

问题描述：

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

Example: 

You may serialize the following tree:

    1
   / \
  2   3
     / \
    4   5

as "[1,2,3,null,null,4,5]"

Clarification: The above format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.

Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

 

解题思路：

参考了Grandyang的解法

需要注意的是istringstream以‘ ’为间断

所以在输入的时候，后面一定要加' '

 

代码：

/**
 * 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) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
private:
    void serialize(TreeNode *root, ostringstream &out){
        if(root){
            out<<root->val<<' ';
            serialize(root->left, out);
            serialize(root->right, out);
        }else{
            out<<"* ";
        }
    }
    TreeNode* deserialize(istringstream &in){
        string val;
        in >> val;
        if(val == "*")
            return nullptr;
        TreeNode *root = new TreeNode(stoi(val));
        root->left = deserialize(in);
        root->right = deserialize(in);
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.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:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string ret = "";
        if(!root) return "*";
        queue<TreeNode*> nodeQ;
        nodeQ.push(root);
        while(!nodeQ.empty()){
            TreeNode* curNode = nodeQ.front();
            nodeQ.pop();
            if(curNode){
                ret.append(to_string(curNode->val));
                nodeQ.push(curNode->left);
                nodeQ.push(curNode->right);
            }else{
                ret.append("*");
            }
            ret.append("_");
        }
        std::cout << ret << std::endl;
        return ret;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data == "*" || data.empty()) return NULL;
        int start = 0;
        TreeNode* root;
        queue<TreeNode*> nodeQ;
        int assignedChild = 0;
        while(start < data.size()){
            int end = data.find("_", start);
            string nodeV = data.substr(start, end-start);
            start = end+1;
            if(nodeQ.empty()){
                int v = atoi(nodeV.c_str());
                TreeNode* n = new TreeNode(v);
                root = n;
                nodeQ.push(n);
            }else{
                TreeNode* pNode = nodeQ.front();
                //std::cout << pNode->val << " : " << nodeV << std::endl;
                if(!pNode) continue;
                if(nodeV != "*"){
                    int v = atoi(nodeV.c_str());
                    TreeNode* child = new TreeNode(v); 
                    nodeQ.push(child);
                    if(assignedChild == 0){
                        pNode->left = child;
                    }else{
                        pNode->right = child;
                    }
                }
                ++assignedChild;
                assignedChild %= 2;
                if(assignedChild == 0){
                    nodeQ.pop();
                }
            }
        }
        
        return root;
    }
};