反序列化（先序）——split : string-->vector<string>

反序列化：将string生成二叉树

先序反序列化操作具体步骤：
（1）先将string字符串进行分割，生成多个string构成的集合保存在vector<string>中；
（2）将vec<string>中的每一个元素存入到queue<string>中
[说明]此时已经将string转换成为能够序列化的queue<string>队列。
/*****************************************************/
（3）对queue<string>队列进行序列化操作
A.参数——queue<string>&，返回值TreeNode*
B.
    获取队头结点存给变量value，并将队头结点出队列
    判断value是否等于NULL（即：value == "#"）
        ①若等于，返回空；
        ②若不等，则new出T结点，并赋值T->str = value;
            再递归创建左子树：T->lchild = recon(Q);
            再递归创建右子树：T->rchild = recon(Q);
            最后返回T

=====================================================





#include <vector>
#include <string>
#include <iostream>
#include <queue>
using namespace std;

typedef struct TreeNode
{
    string data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
}TreeNode;


vector<string> split(const string &s, const string &seperator)  //相当于java中的split函数
{ //返回值是string类型的容器vector<string>

    vector<string> result;
    typedef string::size_type string_size;
    string_size i = 0;

    while (i != s.size()){
        //找到字符串中首个不等于分隔符的字母；
        int flag = 0;
        while (i != s.size() && flag == 0){
            flag = 1;
            for (string_size x = 0; x < seperator.size(); ++x)
                if (s[i] == seperator[x]){
                    ++i;
                    flag = 0;
                    break;
                }
        }

        //找到又一个分隔符，将两个分隔符之间的字符串取出；
        flag = 0;
        string_size j = i;
        while (j != s.size() && flag == 0){
            for (string_size x = 0; x < seperator.size(); ++x)
                if (s[j] == seperator[x]){
                    flag = 1;
                    break;
                }
            if (flag == 0)
                ++j;
        }
        if (i != j){
            result.push_back(s.substr(i, j - i));
            i = j;
        }
    }
    return result;
}

void pretravel(TreeNode* T)  //先序遍历
{
    if (T != NULL)
    {
        cout << T->data << " ";
        pretravel(T->lchild);
        pretravel(T->rchild);
    }
}

TreeNode* Deserialize1(queue<string>& Q) //反序列化操作
{
    string value = Q.front(); //获取队头元素值,并出队
    Q.pop();

    if (value == "#") //NULL
    {
        return NULL;
    }

    TreeNode* T = new TreeNode;  //创建根节点T
    T->data = value;
    T->lchild = Deserialize1(Q); //递归创建左子树
    T->rchild = Deserialize1(Q); //递归创建右子树

    return T;
}

int index = -1;  //定义全局变量

TreeNode* Deserialize2(vector<string>& Arr) 
{
    index++; //依次遍历vector<string>中的每一个元素

    if (index >= Arr.size() || Arr[index] == "#")
    {
        return NULL;
    }

    TreeNode* T = new TreeNode;
    T->data = Arr[index];
    T->lchild = Deserialize2(Arr);
    T->rchild = Deserialize2(Arr);
    return T;
}
int main()
{
    string s = "30,10,50,#,#,#,20,45,#,#,35,#,#";
    vector<string> Arr = split(s, ","); //可按多个字符来分隔

    queue<string> Q;

    for (int i = 0; i < Arr.size(); i++)  //将vec<string>每一个元素存入到queue<string>队列中
        Q.push(Arr[i]);

    TreeNode* head1 = Deserialize1(Q); //反序列化
    pretravel(head1); //先序遍历

    cout << endl;

    TreeNode* head2 = Deserialize2(Arr); //反序列化
    pretravel(head2); //先序遍历

    return 0;
}

剑指offer（64）：序列化二叉树http://blog.youkuaiyun.com/u011080472/article/details/51290794