【剑指offer】29.序列化二叉树

总目录：

算法之旅导航目录

 

1.问题描述 

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。

二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）
二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，可以根据层序遍历的方案序列化，如下图:

 

层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。

当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。

数据范围：节点数 n≤100，树上每个节点的值满足 0≤val≤150

要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)

 

2.问题分析

 1层序遍历，注意处理好空子节点，中间的工程代码真的很多。。。

3.代码实例

1层序遍历

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
#include "math.h"
#include <memory.h>
using namespace std;

class Solution {
  private:
    const char cForSplit = ',', cForStart = '{', cForEnd = '}';
    const int minVal = 0, maxVal = 150, illegalNum = -1;
    const char cForNA = '#';//not a number
    const int maxNumWidth = 4;//0 <= num <= 150
    char* numBuf;

  public:
    //将char队列转到char数组
    char* queueToCharBuf(queue<char>& cQueue) {
        queue<char> seriQ;

        //遍历填充
        //添加起始符
        seriQ.push(cForStart);
        while (!cQueue.empty()) {
            //最后一个分割符不压入
            if (cQueue.size() == 1 && cQueue.front() == cForSplit) {
                break;
            }

            char c = cQueue.front();
            cQueue.pop();
            seriQ.push(c);
        }
        //添加结束符
        seriQ.push(cForEnd);

        //初始化
        int cSize = seriQ.size();
        int bufSize = cSize + 1;//+1 for \0
        char* buf = (char*)malloc(sizeof(char) * bufSize);
        memset(buf, 0, sizeof(char) * bufSize);

        //存入
        int cIndex = 0;
        while (!seriQ.empty()) {
            buf[cIndex++] = seriQ.front();
            seriQ.pop();
        }

        //不可释放buf的内存
        //free(buf);
        return buf;
    }

    //将数字存入char队列，自动添加分割符号
    void addNumToQuque(queue<char>& cBuf, int num) {
        //如果数值范围超限则设定指定符号
        if (num < minVal || num > maxVal) {
            cBuf.push(cForNA);
        } else {
            //准备临时内存，存储数字
            numBuf = numBuf != NULL ? numBuf : (char*)malloc(sizeof(char) * maxNumWidth);
            memset(numBuf, 0, sizeof(char)*maxNumWidth);
            std::sprintf(numBuf, "%d", num);

            //数字-》char数组
            int cIndex = 0;
            while (numBuf[cIndex] != '\0') {
                cBuf.push(numBuf[cIndex++]);
            }

            //记得释放内存
            if (numBuf != NULL) {
                free(numBuf);
            }
            numBuf = NULL;
        }

        //添加分隔符
        cBuf.push(cForSplit);
    }

    //层序迭代，将节点的值逐层存入队列中
    void levelIterSerialize(TreeNode* root, queue<char>& cBuf) {
        if (!root) {
            return;
        }

        int nodeNumInLevel = 0;//指示某层的节点数量，2^(n-1)
        queue<TreeNode*> nodeBuf;
        nodeBuf.push(root);

        //典型的层序迭代
        while (!nodeBuf.empty()) {
            nodeNumInLevel = nodeBuf.size();

            //逐个弹出本层节点并处理
            for (int i = 0; i < nodeNumInLevel; i++) {
                TreeNode* pNode = nodeBuf.front();
                nodeBuf.pop();

                //将本层节点入char队
                addNumToQuque(cBuf, pNode == NULL ? illegalNum : pNode->val);

                //空节点则不添加其下层节点
                if (pNode == NULL) {
                    continue;
                }

                //添加下层节点
                nodeBuf.push(pNode->left);
                nodeBuf.push(pNode->right);
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    //序列化入口
    ////////////////////////////////////////////////////////////////////////////////////////////
    char* Serialize(TreeNode* root) {
        queue<char> cBuf;

        //层序遍历
        levelIterSerialize(root, cBuf);

        //返回序列化字符串
        return queueToCharBuf(cBuf);
    }

    //将char数组转为char队列
    void charBufToQueue(char* str, queue<char>& cQueue) {
        //清空队列
        while (!cQueue.empty()) {
            cQueue.pop();
        }

        //逐char转存
        char* pChar = str;
        while (pChar) {
            if ((*pChar) == '\0') {
                return;
            }

            cQueue.push(*pChar);
            pChar++;
        }
    }

    //从char队列中弹出数字
    bool popNumFromQueue(queue<char>& cQueue, int& outVal) {
        //初始化
        outVal = illegalNum;
        if (cQueue.empty()) {
            return false;
        }

        //排除调队列前端的无用字符
        while (!cQueue.empty()) {
            char tmp = cQueue.front();
            if ( tmp != cForStart && tmp != cForSplit && tmp != cForEnd) {
                break;
            }

            //弹出
            cQueue.pop();
        }

        //逐char解析，将属于该数字的一段从队列中弹出
        queue<char> tempQueue;
        while (!cQueue.empty()) {
            char c = cQueue.front();
            cQueue.pop();

            //若干可能的中断情况
            //跳过起始符
            if (c == cForStart) {
                continue;
            }
            //遇到分割符和结束符则中止
            if (c == cForSplit || c == cForEnd) {
                break;
            }
            //发现占位符，立即返回非法数字
            if (c == cForNA) {
                outVal = illegalNum;
                return true;
            }

            //存入临时队列
            tempQueue.push(c);
        }

        //queue转入char数组
        int charCount = tempQueue.size();
        if (charCount <= 0) {
            return false;
        }
        int bufSize = charCount + 1;
        char* cBuf = (char*)malloc(sizeof(char) * (bufSize));
        memset(cBuf, 0, sizeof(char) * (bufSize));
        int charIndex = 0;
        while (!tempQueue.empty()) {
            cBuf[charIndex++] = tempQueue.front();
            tempQueue.pop();
        }

        //char数组转数字
        outVal = std::atoi(cBuf);
        free(cBuf);

        return true;
    }

    //层序遍历，反序列化
    TreeNode* levelIterDeserialize(queue<char>& cQueue) {
        int curVal = illegalNum;
        bool gotNum = false;

        //是否存在根节点
        gotNum = popNumFromQueue(cQueue, curVal);
        if (!gotNum) {
            return NULL;
        }

        //典型的层序遍历
        int nodeNunInLevel = 0;
        TreeNode* head = new TreeNode(curVal);
        queue<TreeNode*> nodeQueue;
        nodeQueue.push(head);
        while (!nodeQueue.empty()) {
            nodeNunInLevel = nodeQueue.size();
            for (int i = 0; i < nodeNunInLevel; i++) {
                TreeNode* root = nodeQueue.front();
                nodeQueue.pop();

                //left
                gotNum = popNumFromQueue(cQueue, curVal);
                if (!gotNum) {
                    return head;
                }
                if (curVal != illegalNum) {
                    root->left = new TreeNode(curVal);
                    nodeQueue.push(root->left);
                }

                //right
                gotNum = popNumFromQueue(cQueue, curVal);
                if (!gotNum) {
                    return head;
                }
                if (curVal != illegalNum) {
                    root->right = new TreeNode(curVal);
                    nodeQueue.push(root->right);
                }
            }
        }

        return head;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    //反序列化入口
    ////////////////////////////////////////////////////////////////////////////////////////////
    TreeNode* Deserialize(char* str) {
        if (!str) {
            return NULL;
        }

        //将char*转为char队列，方便处理
        queue<char> cQueue;
        charBufToQueue(str, cQueue);

        return levelIterDeserialize(cQueue);
    }
};