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 {
private:
    vector<string> split(string src, string delimeter) {
        if (src.empty()) return {};
        vector<string> ans;
        int pos1 = 0, pos2 = src.find(delimeter);
        while (pos2 != string::npos) {
            ans.push_back(src.substr(pos1, pos2 - pos1));
            pos1 = pos2 + delimeter.size();
            pos2 = src.find(delimeter, pos1);
        }
        if (pos1 != src.size())
            ans.push_back(src.substr(pos1));
        return ans;
    }

    TreeNode* deserialize(vector<string>& nums, int& i) {
        if (i == nums.size()) return nullptr;
        if (nums[i] == "#") {
            i++;
            return nullptr;
        }
        TreeNode* root = new TreeNode(stoi(nums[i]));
        i++;
        root->left = deserialize(nums, i);
        root->right = deserialize(nums, i);
        return root;
    }
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        if (!root) return "#";
        else
            return to_string(root->val) + ","  + serialize(root->left) + "," + serialize(root->right);
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        vector<string> nums = split(data, ",");
        int i = 0;
        TreeNode* res = deserialize(nums, i);
        return res;
    }
};

// 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) {
        if (!root) {
            return "";
        }
        std::string result;
        std::vector<TreeNode*> vec;
        vec.push_back(root);
        for (int i = 0; i < vec.size(); ++i) {
            if (vec[i]) {
                vec.push_back(vec[i]->left);
                vec.push_back(vec[i]->right);
            }
        }
        result += to_string(vec[0]->val);
        for (int i = 1; i < vec.size(); ++i) {
            TreeNode* node = vec[i];
            result += ",";
            if (node) {
                result += to_string(node->val);
            } else {
                result += "#";
            }
        }
        return result;
    }
    vector<string> split(string src, string delimeter) {
        if (src.empty()) return {};
        vector<string> ans;
        int pos1 = 0, pos2 = src.find(delimeter);
        while (pos2 != string::npos) {
            ans.push_back(src.substr(pos1, pos2 - pos1));
            pos1 = pos2 + delimeter.size();
            pos2 = src.find(delimeter, pos1);
        }
        if (pos1 != src.size())
            ans.push_back(src.substr(pos1));
        return ans;
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if (data.empty()) {
            return nullptr;
        }
        std::vector<std::string> result = split(data, ",");
        std::queue<TreeNode*> que;
        TreeNode* root = new (std::nothrow)TreeNode(atoi(result[0].c_str()));
        que.push(root);
        bool is_left_node = true;
        for (int i = 1; i < result.size(); ++i) {
            if (result[i] != "#") {
                TreeNode* node = new (std::nothrow)TreeNode(atoi(result[i].c_str()));
                if (is_left_node) {
                    que.front()->left = node;
                } else {
                    que.front()->right = node;
                }
                que.push(node);
            }
            if (!is_left_node) {
                que.pop();
            }
            is_left_node = !is_left_node;
        }
        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) {
        if (!root) {
            return "";
        }
        std::queue<TreeNode*> que;
        std::string result;
        que.push(root);
        //result += std::to_string(root->val);
        while (!que.empty()) {
            auto f = que.front();
            que.pop();
            if (f) {
                result += std::to_string(f->val) + ",";
                que.push(f->left);
                que.push(f->right);
            } else {
                result += "#,";
            }
        }
        cout << result << endl;
        return result;
    }
    vector<string> split(string src, string delimeter) {
        if (src.empty()) return {};
        vector<string> ans;
        int pos1 = 0, pos2 = src.find(delimeter);
        while (pos2 != string::npos) {
            ans.push_back(src.substr(pos1, pos2 - pos1));
            pos1 = pos2 + delimeter.size();
            pos2 = src.find(delimeter, pos1);
        }
        if (pos1 != src.size())
            ans.push_back(src.substr(pos1));
        return ans;
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if (data.empty()) {
            return nullptr;
        }
        std::vector<std::string> result = split(data, ",");
        std::queue<TreeNode*> que;
        TreeNode* root = new (std::nothrow)TreeNode(atoi(result[0].c_str()));
        que.push(root);
        bool is_left_node = true;
        for (int i = 1; i < result.size(); ++i) {
            if (result[i] != "#") {
                TreeNode* node = new (std::nothrow)TreeNode(atoi(result[i].c_str()));
                if (is_left_node) {
                    que.front()->left = node;
                } else {
                    que.front()->right = node;
                }
                que.push(node);
            }
            if (!is_left_node) {
                que.pop();
            }
            is_left_node = !is_left_node;
        }
        return root;
    }
};

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