二叉树的序列化

最新推荐文章于 2024-07-18 18:08:02 发布

砍柴人Ryan

最新推荐文章于 2024-07-18 18:08:02 发布

阅读量153

点赞数

分类专栏：刷题文章标签：二叉树

本文链接：https://blog.csdn.net/No_one_z/article/details/110720468

版权

刷题专栏收录该内容

118 篇文章 2 订阅

订阅专栏

本文介绍如何实现二叉树的序列化和反序列化，具体过程包括先序序列化和层序序列化。在序列化过程中，遇到空节点用 '#' 表示，并附加 '!'。给定一颗二叉树，根据描述将其序列化成字符串。

摘要由CSDN通过智能技术生成

题目描述

二叉树被记录为文件的过程叫作二叉树的序列化，通过文件内容重建原来二叉树的过程叫作二叉树的反序列化，给定一颗二叉树，请将该二叉树先序序列化和层序序列化。

假设序列化的结果字符串为 str，初始时 str = ""，遍历二叉树时，遇到 null 节点，则在 str 的末尾加上 "#!"，否则加上"当前的节点值!"。

输入描述:

第一行输入两个整数 n 和 root，n 表示二叉树的总节点个数，root 表示二叉树的根节点。
以下 n 行每行三个整数 fa，lch，rch，表示 fa 的左儿子为 lch，右儿子为 rch。(如果 lch 为 0 则表示 fa 没有左儿子，rch同理)

输出描述:

输出两行分别表示该二叉树的先序序列化和层序序列化

示例1

输入

2 1
1 2 0
2 0 0

输出

1!2!#!#!#!
1!2!#!#!#!

#include<iostream>
#include<vector>
#include<queue>

using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(NULL),right(NULL){}
};
void createTree(TreeNode *root,int cnt){
    if(cnt==0)
        return;
    int p, l, r;
    cin>>p>>l>>r;
    if(l!=0){
        TreeNode* left=new TreeNode(l);
        root->left=left;
        createTree(root->left, --cnt);
    }
    if(r!=0){
        TreeNode* right=new TreeNode(r);
        root->right=right;
        createTree(root->right, --cnt);
    }
}
void preorder(TreeNode* root){
    if(root==nullptr){
        cout<<"#!";
        return;
    }
    cout<<root->val<<"!";
    preorder(root->left);
    preorder(root->right);
}
void level_order(TreeNode* root){
    if(root==NULL){
        cout<<"#!";
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()){
        TreeNode* tmp=q.front();
        q.pop();
        if(tmp==nullptr){
            cout<<"#!";
            continue;
        }else{
            cout<<tmp->val<<"!";
            q.push(tmp->left);
            q.push(tmp->right);
        }
    }
}
int main(){
    int n, r;
    cin>>n>>r;
    TreeNode* root=new TreeNode(r);
    createTree(root, n);
    preorder(root);
    cout<<endl;
    level_order(root);
    return 0;
}

/**
 * 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 data;
        queue<TreeNode*> que;
        if(root) que.push(root);

        while(!que.empty()){
            TreeNode* cur = que.front();
            que.pop();
            if(cur){
                data+=to_string(cur->val)+",";
                que.push(cur->left);
                que.push(cur->right);
            }else{
                data+="null,";
            }
        }
        if(!data.empty()) data.pop_back();
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        unique_ptr<TreeNode> dummy(new TreeNode(0));
        queue<TreeNode*> que;
        que.push(dummy.get());
        size_t beg=0, end=0;
        bool left_side=false;

        while(beg<data.size()){
            while(end<data.size() && data[end]!=',') ++end;
            auto str=data.substr(beg, end-beg);
            TreeNode* node = NULL;
            if(str!="null") node=new TreeNode(atoi(str.c_str()));

            auto cur = que.front();
            if(left_side){
                cur->left=node;
            }else{
                cur->right=node;
                que.pop();
            }
            if(node) que.push(node);
            left_side=!left_side;
            beg=++end;
        }
        return dummy->right;
    }
};

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