【宽度优先搜索BFS】Lintcode 7. 二叉树的序列化和反序列化

Lintcode 7. 二叉树的序列化和反序列化

题目描述：设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。
如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符串反序列化为原来的树结构。

这道题目用到了BFS进行序列化和反序列化，但因为涉及到字符级的处理，题目会比较繁琐。下面的实现基本参照了答案，先在此记录一下，找时间完全自己实现一遍。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */


class Solution {
public:
    /**
     * This method will be invoked first, you should design your own algorithm 
     * to serialize a binary tree which denote by a root node to a string which
     * can be easily deserialized by your own "deserialize" method later.
     */
    string serialize(TreeNode * root) {
        if (root == nullptr) {
            return "{}";
        }
        vector<TreeNode *> nodes;
        queue<TreeNode *> nodeQueue;
        
        // 宽度优先搜索获得BFS序
        nodeQueue.push(root);
        while (not nodeQueue.empty()) {
            TreeNode * node = nodeQueue.front();
            nodeQueue.pop();
            nodes.push_back(node);
            if (node == nullptr) {
                continue;
            }
            nodeQueue.push(node -> left);
            nodeQueue.push(node -> right);
        }
        while (nodes.back() == nullptr) {
            nodes.pop_back();
        }
        
        //将BFS序序列化
        string result;
        result += '{';
        for (int i = 0; i < nodes.size(); i++) {
            if (i > 0) {
                result += ',';
            }
            if (nodes[i] == nullptr) {
                result += '#';
            }
            else {
                result += to_string(nodes[i] -> val);
            }
        }
        result += '}';
        return result;
    }

    /**
     * This method will be invoked second, the argument data is what exactly
     * you serialized at method "serialize", that means the data is not given by
     * system, it's given by your own serialize method. So the format of data is
     * designed by yourself, and deserialize it here as you serialize it in 
     * "serialize" method.
     */
    TreeNode * deserialize(string &data) {
        if (data == "{}") {
            return nullptr;
        }
        int len = data.length();
        vector<string> bfsOrder = split(data.substr(1, len - 2));
        int n = bfsOrder.size();
        TreeNode * root = getTreenode(bfsOrder[0]);
        queue<TreeNode *> nodeQueue;
        int pointer = 1;
        
        // 分层进行宽度优先搜索
        // 获得该层的节点个数level_size，并将接下来level_size * 2个值连接到节点上
        nodeQueue.push(root);
        while (not nodeQueue.empty()) {
            if (pointer < n) {
                int levelSize = nodeQueue.size();
                for (int i = 0; i < levelSize; i++) {
                    TreeNode * node = nodeQueue.front();
                    nodeQueue.pop();
                    
                    node -> left = getTreenode(bfsOrder[pointer]);
                    if (node -> left != nullptr) {
                        nodeQueue.push(node -> left);
                    }
                    pointer++;
                    if (pointer == n) {
                        break;
                    }
                    
                    node -> right = getTreenode(bfsOrder[pointer]);
                    if (node -> right != nullptr) {
                        nodeQueue.push(node -> right);
                    }
                    pointer++;
                    if (pointer == n) {
                        break;
                    }
                }
            }
            else {
                break;
            }
        }
        return root;
    }
    TreeNode * getTreenode(const string& s) {
        if (s == "#") {
            return nullptr;
        }
        else {
            return new TreeNode(strToInt(s));
        }
    }
    vector<string> split(const string& s) {
        string temp = "";
        vector<string> result;    
        for (char c: s) {
            if (c == ',') {
                result.push_back(temp);
                temp = "";
            }
            else {
                temp += c;
            }
        }
        result.push_back(temp);
        return result;
    }
    int strToInt(const string& s) {
        int result = 0;
        for (char c: s) {
            result = result * 10 + c - '0';
        }
        return result;
    }
};