剑指 Offer 37. 序列化二叉树

最新推荐文章于 2024-10-02 21:42:12 发布

辰景

最新推荐文章于 2024-10-02 21:42:12 发布

阅读量282

点赞数 1

分类专栏： leetcode 文章标签：蓝桥杯 c++ 数据结构

本文链接：https://blog.csdn.net/weixin_43098069/article/details/122526718

版权

leetcode 专栏收录该内容

173 篇文章 2 订阅

订阅专栏

题目描述：

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

你需要设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示：输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

示例：

输入：root = [1,2,3,null,null,4,5]
输出：[1,2,3,null,null,4,5]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析：就我而言，我看到这道题，想法就是，serialize函数根据root得到前序遍历序列pre和中序遍历序列mid，然后令data=pre+mid，传递给deserialize函数，然后deserialize函数进行解析，还原出前序遍历序列pre和中序遍历序列mid，再根据这两个序列来构造树。

代码如下：

/**
 * 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 pre;
        string mid;
        pre=prebianli(root,pre);
        mid=midbianli(root,mid);
        return  pre+"|"+mid;

    }
    string prebianli(TreeNode *root,string &pre)
    {
        if(root==NULL) return pre;
        pre=pre+to_string(root->val)+" ";
        pre=prebianli(root->left,pre);
        pre=prebianli(root->right,pre);
        return pre;
        
    }
    string midbianli(TreeNode *root,string &mid)
    {
        if(root==NULL) return mid;
        mid=midbianli(root->left,mid);
        mid=mid+to_string(root->val)+" ";
        mid=midbianli(root->right,mid);
        return mid;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        cout<<"data is "<<data<<endl;
        int l=data.length();
        vector<int> pre;
        vector<int> mid;

        string temppre;
        string tempmid;
        int flag=false;
        for(int i=0;i<l;i++)
        {
            if((data[i]!='|')&&!flag)
            temppre+=data[i];
            else if(data[i]=='|')
            {
                flag=true;
                continue;
            }
            if(flag)
            tempmid+=data[i];
        }
        pre=stringtoint(temppre);
        mid=stringtoint(tempmid);
        
        TreeNode* root= buildTree(pre,mid);
        return root;
        return NULL;
    }
    vector<int> stringtoint(string data)
    {
        string temp;
        vector<int> res;
        
        for(int i=0;i<data.length();i++)
        {
            if(data[i]==' ')
            {
                
                res.push_back(stoi(temp));
                temp="";
                continue;
            }
            else
            {
                temp+=data[i];
            }
        }
        return res;
    }
    TreeNode* buildTree(vector<int> &pre,vector<int> &mid)
    {
        if(pre.size()==0||mid.size()==0)
        return NULL;
        int midindex;
        for(int i=0;i<mid.size();i++)
        if(pre[0]==mid[i])
        {
            midindex=i;
            
            break;
        }
        vector<int> pre1,pre2,mid1,mid2;
        for(int i=0;i<midindex;i++)
        mid1.push_back(mid[i]);
        
        for(int i=midindex+1;i<mid.size();i++)
        mid2.push_back(mid[i]);
        for(int i=1;i<mid1.size()+1;i++)
        pre1.push_back(pre[i]);
        for(int i=mid1.size()+1;i<mid.size();i++)
        pre2.push_back(pre[i]);

        
        
        TreeNode *root=new TreeNode(pre[0]);
        root->left=buildTree(pre1,mid1);
        root->right=buildTree(pre2,mid2);
        return root;

    }
};

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

前序遍历和中序遍历能唯一确定一个二叉树，但貌似只适用于树中的节点互不相同，例如：前序遍历序列[1,1,1,1,1]，中序遍历序列[1,1,1,1,1]，我们是没办法知道这个二叉树的结构的。

但这道题偏偏二叉树里的节点有相同的，因此这种方法不行。而且这道题似乎有些问题，输入的顺序是层序遍历的结果，但是读取的时候是前序遍历。。。。。唉，没办法，前序遍历序列中加上叶子结点的左右节点，即空节点，即可判断出该树的结构。例如示例，正常的前序遍历是：[1,2,3,4,5]，但是，加上了叶子结点的左右空节点后，就变成了[1,2,null,null,3,4,null,null,5,null,null]，可以确定树的结构了，故可以删去中序遍历序列，只适用带有空节点的前序遍历序列即可。

代码如下：

/**
 * 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 pre;
        // 得到带有空节点的前序遍历序列
        pre=prebianli(root);
        return  pre;
    }
    string prebianli(TreeNode *root)
    {
        // 以'#'代表空节点
        if(root==NULL) return "#";
        
        return to_string(root->val)+" "+prebianli(root->left)+" "+prebianli(root->right);
        
    }
    
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        int l=data.length();
        vector<string> pre;
        string temp;
        // 把string类型的data转换为vector类型的string
        for(int i=0;i<l;i++)
        {
            if(data[i]==' ')
            {
                // cout<<"temp is "<<temp<<endl;
                pre.push_back(temp);
                temp="";
                continue;
            }
            else
            {
                temp+=data[i];
            }
        }
        if(temp!="")
        pre.push_back(temp);
        // pre=stringtoint(data);
        // cout<<"pre length is "<<pre.size()<<endl;
        // 根据pre来构建树
        TreeNode* root= buildTree(pre);
        return root;
    }
    
    int index=0;
    TreeNode* buildTree(vector<string> &pre)
    {
        
        if(pre.size()==0)
        return NULL;
        // 遇到了空节点，就返回NULL
        if(pre[index]=="#"||index>=pre.size())
        {
            index++;
            return NULL;
        }

        int n = 0;
        // 把string类型的pre[index]转换为int
        stringstream ss(pre[index]);
        ss >> n;
        // 构造根节点
        TreeNode *root=new TreeNode(n);
        // 前序遍历中这个节点已经使用过了，前往下一个节点
        index++;
        // 构造左右子树
        root->left=buildTree(pre);
        root->right=buildTree(pre);
        return root;

    }
};

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

这是精简后的代码，如果写的稍微复杂一些，就会超时。。。。。

例如prebianli函数这样写：

string prebianli(TreeNode *root)
    {
        
        if(root==NULL) return "#";
        pre=pre+to_string(root->val)+" ";
        pre=pre+prebianli(root->left);
        pre=pre+prebianli(root->right);
        return pre;
        
    }

就会超时。。。

我还是觉得这道题问题很大。。。但也只能这样了。