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

反序列化：將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.csdn.net/u011080472/article/details/51290794