LeetCode 449 序列化和反序列化二叉搜索树[二叉树 序列化 前序 中序 后序] HERODING的LeetCode之路

Posted HERODING23

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode 449 序列化和反序列化二叉搜索树[二叉树 序列化 前序 中序 后序] HERODING的LeetCode之路相关的知识,希望对你有一定的参考价值。


解题思路:
如果做过297. 二叉树的序列化与反序列化这道题的话,那么本题无需更改,直接沿用即可(本题只是在297基础上多了一个二叉搜索树的条件),297的思想是将整个二叉树层次遍历序列化成字符串(包括null也序列化),在反序列化中转化为数组形式(根据‘,’划分),然后根据根与左右节点的关系(2index+1和2index+2,index是根在数组中下标),重构二叉树,如果还不清楚可以看我的这篇博客,代码如下:

/**
 * 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 res;
        // 如果根为空
        if(root == nullptr) 
            return res;
         
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()) 
            TreeNode* demo = q.front();
            q.pop();
            if(demo != nullptr) 
                res += to_string(demo -> val) + ",";
                q.push(demo -> left);
                q.push(demo -> right);
             else 
                res += "null,";
            
        
        return res;
    

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) 
        if(data == "") 
            return nullptr;
        
        vector<string> vals;
        // 分割字符串
        string s;
        for(int i = 0; i < data.size(); i ++) 
            if(data[i] == ',') 
                vals.push_back(s);
                s = "";
             else 
                s += data[i];
            
        
        TreeNode* root = new TreeNode(atoi(vals[0].c_str()));
        queue<TreeNode*> q;
        q.push(root);
        // 标记当前根的位置
        int i = 0;
        while(!q.empty()) 
            TreeNode* demo = q.front();
            q.pop();
            // 有左节点
            if(vals[i * 2 + 1] != "null") 
                demo -> left = new TreeNode(atoi(vals[i * 2 + 1].c_str()));
                q.push(demo -> left);
            
            // 有右节点
            if(vals[i * 2 + 2] != "null") 
                demo -> right = new TreeNode(atoi(vals[i * 2 + 2].c_str()));
                q.push(demo -> right);
            
            i ++;
        
        return root;
    
;

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



但是题目既然给了搜索二叉树这个条件,那么最好能利用上,搜索二叉树的中序遍历就是从小到大的排序,所以只要获得前序遍历或者后序遍历,就可以重构二叉树,首先是前序遍历的方法,根据搜索二叉树获得前序遍历,然后将前序遍历结果转换为string输出,反序列化接收输出并转化回数组,排序后获得中序遍历结果,根据前序遍历获得根,中序遍历知左右,构建出搜索二叉树,注意,为了方便左右递归(根据中序遍历中根左边为左子树,右边为右子树),用哈希表记录下中序遍历中数和index的关系,代码如下:

/**
 * 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:
    unordered_map<int, int> mp;
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) 
        vector<int> pre;
        dfs(root, pre);
        string data;
        for(int i = 0; i < pre.size(); i ++) 
            data += to_string(pre[i]) + ',';
        
        return data;
    

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) 
        // 获取前序遍历和中序遍历
        vector<int> pre;
        string s;
        for(int i = 0; i < data.size(); i ++) 
            if(data[i] == ',') 
                pre.emplace_back(atoi(s.c_str()));
                s = "";
             else 
                s += data[i];
            
        
        vector<int> in = pre;
        sort(in.begin(), in.end());
        int n = pre.size();
        // 存储中序遍历下标
        for(int i = 0; i < n; i ++) 
            mp[in[i]] = i;
        
        // idx指向根节点下标
        int idx = 0;
        // 构建树
        return build(in, pre, 0, n - 1, idx);
    

    // 构建树
    TreeNode* build(vector<int>& in, vector<int>& pre, int l, int r, int& idx) 
        if(l > r) return nullptr;
        // 区间只有一个元素,直接返回该元素
        if(l == r) 
            idx ++;
            return new TreeNode(in[l]);
        
        int root = pre[idx ++];
        int index = mp[root];
        TreeNode* tree = new TreeNode(root);
        tree->left = build(in, pre, l, index - 1, idx);
        tree->right = build(in, pre, index + 1, r, idx);
        return tree;
    

    // 前序遍历
    void dfs(TreeNode* root, vector<int>& pre) 
        if(root == nullptr) return;
        pre.emplace_back(root -> val);
        dfs(root->left, pre);
        dfs(root->right, pre); 
    
;

// Your Codec object will be instantiated and called as such:
// Codec* ser = new Codec();
// Codec* deser = new Codec();
// string tree = ser->serialize(root);
// TreeNode* ans = deser->deserialize(tree);
// return ans;

后序遍历也是同样的操作,只不过根在最后,简单修改即可,代码如下:

/**
 * 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:
    unordered_map<int, int> mp;
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) 
        vector<int> post;
        dfs(root, post);
        string data;
        for(int i = 0; i < post.size(); i ++) 
            data += to_string(post[i]) + ',';
                
        return data;
    

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) 
        // 获取后序遍历和中序遍历
        vector<int> post;
        string s;
        for(int i = 0; i < data.size(); i ++) 
            if(data[i] == ',') 
                post.emplace_back(atoi(s.c_str()));
                s = "";
             else 
                s += data[i];
            
        
        vector<int> in = post;
        sort(in.begin(), in.end());
        int n = in.size();
        // 存储中序遍历下标
        for(int i = 0; i < n; i ++) 
            mp[in[i]] = i;
        
        // idx指向根节点下标
        int idx = n - 1;
        // 构建树
        return build(in, post, 0, n - 1, idx);
    

    // 构建树
    TreeNode* build(vector<int>& in, vector<int>& post, int l, int r, int& idx) 
        if(l > r) return nullptr;
        // 区间只有一个元素,直接返回该元素
        if(l == r) 
            idx --;
            return new TreeNode(in[l]);
        
        int root = post[idx --];
        int index = mp[root];
        TreeNode* tree = new TreeNode(root);
        tree->right = build(in, post, index + 1, r, idx);
        tree->left = build(in, post, l, index - 1, idx);
        return tree;
    

    // 后序遍历
    void dfs(TreeNode* root, vector<int>& post) 
        if(root == nullptr) return;
        dfs(root->left, post);
        dfs(root->right, post);
        post.emplace_back(root -> val);
    
;

// Your Codec object will be instantiated and called as such:
// Codec* ser = new Codec();
// Codec* deser = new Codec();
// string tree = ser->serialize(root);
// TreeNode* ans = deser->deserialize(tree);
// return ans;

以上是关于LeetCode 449 序列化和反序列化二叉搜索树[二叉树 序列化 前序 中序 后序] HERODING的LeetCode之路的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode 942. 增减字符串匹配 / 1728. 猫和老鼠 II(博弈,不会) / 449. 序列化和反序列化二叉搜索树

449. 序列化和反序列化二叉搜索树

LeetCode 五月打卡-day11

Leetcode 297.二叉树的序列化和反序列化

数据结构与算法之深入解析“序列化和反序列化二叉搜索树”的求解思路与算法示例

二叉树的序列化和反序列化