剑指offer---序列化二叉树

最新推荐文章于 2019-03-31 20:35:45 发布

原创最新推荐文章于 2019-03-31 20:35:45 发布 · 265 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#剑指offer #序列化二叉树

剑指offer 专栏收录该内容

40 篇文章

订阅专栏

本文介绍了一种利用前序遍历方法实现二叉树的序列化与反序列化的过程。通过使用特殊字符表示空节点，并采用递归方式处理节点，实现了二叉树结构的有效编码和解码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树序列化

我们以前序遍历的顺序进行序列化，对于空结点我们用一个特殊的符号‘$’来代替，则序列化后的字符串为“1 2 4 $ $ 5 $ $ 3 6 $ $ 7 $ $”

数组vector<int>：1 2 4 0xFFFFFFFF 0xFFFFFFFF 5 0xFFFFFFFF 0xFFFFFFFF 3 6 0xFFFFFFFF 0xFFFFFFFF 7 0xFFFFFFFF 0xFFFFFFFF

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    //序列化，深度优先遍历（先序遍历）
    vector<int> buf;
    void dfs1(TreeNode *root){
        if(!root) buf.push_back(0xFFFFFFFF);
        else{
            buf.push_back(root->val);
            dfs1(root->left);
            dfs1(root->right);
        }
    }
    char* Serialize(TreeNode *root){
        buf.clear();
        dfs1(root);
        int *res=new int[buf.size()];
        for(int i=0;i<buf.size();++i) res[i]=buf[i];
        return (char*)res;
    }
    TreeNode* dfs2(int * &p){
        if(*p==0xFFFFFFFF){
            p++;
            return nullptr;
        }
        TreeNode *node=new TreeNode(*p);
        p++;
        node->left=dfs2(p);
        node->right=dfs2(p);
        return node;
    }
    TreeNode* Deserialize(char *str){
        int *p=(int*)str;
        return dfs2(p);
    }
    /*
    vector<int> buf;
    //按深度优先遍历
    void dfs1(TreeNode *root) {
        if(!root) buf.push_back(0xFFFFFFFF);
        else {
            buf.push_back(root->val);
            dfs1(root->left);
            dfs1(root->right);
        }
    }
    TreeNode* dfs2(int* &p) {
        if(*p==0xFFFFFFFF) {
            p++;
            return NULL;
        }
        TreeNode* res=new TreeNode(*p);
        p++;
        res->left=dfs2(p);
        res->right=dfs2(p);
        return res;
    }
    char* Serialize(TreeNode *root) {//序列化
        buf.clear();
        dfs1(root);
        int bufSize=buf.size();
        int *res=new int[bufSize];
        for(int i=0;i<bufSize;i++) res[i]=buf[i];
        return (char*)res;
    }
    TreeNode* Deserialize(char *str) {//反序列化
        int *p=(int*)str;
        return dfs2(p);
    }
    */
    /*
    //=========================二叉树序列化==============前序遍历================
    char* Serialize(TreeNode *root) {  
        if (root == NULL)  
            return NULL;  
        string str;  
        serialize(root, str);  
        char* buffer = new char[str.size() + 1];                  
        strcpy(buffer, str.c_str());//将string类型的字符串转换成C_style类型并复制到一个char类型数组  
        return buffer;  
    }

    void serialize(TreeNode* root, string& str)  
    {  
        if (root == NULL)  
        {  
            str += "$,";//叶子结点的左右子结点为空则用 $ 来代替  
            return;  
        }  
        str += to_string(root->val);//将结点值（int）转换成字符串（string）类型  
        str += ',';  
        serialize(root->left, str);//递归序列化结点的左子树  
        serialize(root->right, str);//递归序列化结点的右子树  
    }  
  
    //========================二叉树反序列化============================
    TreeNode* Deserialize(char *str) {  
        if (str == NULL)  
            return NULL;  
        return deserialize(&str);  
    }  
  
    TreeNode* deserialize(char** str)  
    {  
        if (**str == '$')  
        {  
            (*str) += 2;  
            return NULL;  
        }  
        int val = 0;  
        while (**str != ','&&**str != '\0')//把字符串类型的数字转换成int类型的数字  
        {  
            val = val * 10 + (**str - '0');
            ++(*str);  
        }  
        TreeNode* root = new TreeNode(val);//构建根结点  
        if (**str == '\0')  
            return root;  
        else  
            ++(*str);  
        root->left = deserialize(str);//递归的构建左子树结点  
        root->right = deserialize(str);//递归的构建右子树结点  
        return root;  
    }
    */
};