Leetcode第297题 二叉树的序列化与反序列化 C++ BFS解法

想了一晚上，用BFS去做，好长的代码啊

class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        if(root==NULL)
        return {};
        TreeNode *pmove=root;
        stringstream ss;//采用字符流，使转换不太复杂
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty())
        {
            pmove=queue.front();
            queue.pop();
            if(pmove!=NULL)
            {
                ss<<pmove->val<<';';//分隔符采用';',如果要删除后面多余的null，步骤比较简单
                //res+=to_string(pmove->val)+';';//如果不采用字符流，需要使用to_string处理
                queue.push(pmove->left);
                queue.push(pmove->right);
            }
            else
            ss<<"null;";
        }
        string res=ss.str();
        //如果要删除后面多余的null，需要的处理
        // for(string::iterator it=res.end()-1;*it>=';';--it)
        //     res.erase(it,res.end());
        // res+=';';
        return res;        
    }

    TreeNode* helpDecode(vector<TreeNode*> &trans)
    {
        int i=0;
        TreeNode *root=trans[i];
        queue<TreeNode*> queue;
        TreeNode *pmove=root;
        queue.push(pmove);
        int now,next=1;
        while(!queue.empty())
        {
            //记录上一层结点数目，同时清空重新计数
            now=next;
            //i为本层第一个结点的序号，now为本层结点的数目，i+now即为下一层第一个结点的序号
            i=i+now;
            next=0;
            while(!queue.empty())
            {
                pmove=queue.front();
                queue.pop();
                if(pmove!=NULL)
                    {
                        //一个结点的左右结点与本层结点的情况有关;
                        //如果结点非空，则下一个结点的左右结点的序号需要累积加2
                        pmove->left=trans[i+next];
                        pmove->right=trans[i+next+1];
                        next=next+2;
                    }   
            }
            //入队下一层结点       
            for(int k=0;k<next;k++)
                queue.push(trans[i+k]);             
        }
        return root;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.size()==0)
        return NULL;
        vector<TreeNode*> trans;        
        for(int i=0;i<data.size();++i)
        {
            stringstream ss;
            int rval;
            TreeNode *node=NULL;//初始为空结点
            for(;data[i]!=';';++i)
                ss<<data[i];
            if(ss.str()!="null")//处理非空结点的情况
            {   
                ss>>rval;
                node=new TreeNode(rval);
            }
            trans.push_back(node);
        }
        return helpDecode(trans);
    }
};

再简化下反序列化的代码

    TreeNode* helpDecode(vector<TreeNode*> &trans)
    {
        int i=0;
        queue<int> queue;
        queue.push(i);
        TreeNode *root=trans[i++];
        TreeNode *pmove;
        //同样用BFS来做反序列化，然而使用标准模板公式，内存会超出限制，一开始我以为是queue<TreeNode*>造成的，改用queue<int>减小空间，没想到还是不行。后来发现是主函数deserialize的问题，看来使用字符流处理才行，当然用字符数组也可以
        
        while(i<trans.size())
        {
        pmove=trans[queue.front()];
        queue.pop();
        if(pmove!=NULL)
            {
                pmove->left=trans[i];
                pmove->right=trans[i+1];
                queue.push(i++);
                queue.push(i++);
            }            
        }
        return root;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.size()==0)
        return NULL;
        vector<TreeNode*> trans;        
        while(data.size()!=0)
        {
            TreeNode *node=NULL;
            int pos=data.find(";");
            string ss=data.substr(0,pos);//使用函数substr来处理字符串
            data=data.substr(pos+1,data.size());          
            if(ss!="null")//处理非空结点的情况
                node=new TreeNode(stoi(ss));
            trans.push_back(node);
        }
        return helpDecode(trans);
    }
};

最新学习成果，采用字符流处理的话，如果字符之间间隔是“ ”可以很方便的分割

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.size()==0)
        return NULL;
        istringstream ss(data);
        string s;
        vector<TreeNode*> trans;        
        while((ss>>s))
        {
            TreeNode *node=NULL;
            if(s!="null")//处理非空结点的情况
                node=new TreeNode(stoi(s));
            trans.push_back(node);
        }
        return helpDecode(trans);
    }
};