序列化和反序列化二叉树

今天练习算法，在leetcode上做了一道练习，照着上面的分析写了下面的代码，编译执行也都没有问题，在这里写写。

这里采用二叉树的先序遍历方式作为序列化和反序列化的主要思路，对空的子树用'#'进行记录。

在序列化的时候，使用递归进行先序遍历，递归执行到空节点，则保存'#'并返回；否则记录当前节点的值，并继续对其左右节点进行遍历。

同样，在反序列化的时候，当前读到的值作为新子树的根节点root，下一个读到的节点则为root节点的左子树root->left，并将当前索引值的引用传入下一步的递归，直到读到'#'递归层层返回；因为递归调用传入了当前值的引用，所以递归返回到root时，下一个读到的值将会用来初始化root的右子树root->right。

#include <cstdio>
#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <vld.h>

using namespace std;

struct TreeNode
{
    int i_val;
    TreeNode *p_left;
    TreeNode *p_right;
    TreeNode() : i_val(0), p_left(0), p_right(0) {}
    TreeNode(int val) : i_val(val), p_left(0), p_right(0) {}
    TreeNode(const TreeNode &treeNode) : i_val(treeNode.i_val), p_left(treeNode.p_left), p_right(treeNode.p_right) {}
    TreeNode &operator=(const TreeNode &treeNode)
    {
        if(this != &treeNode)
        {
            this->i_val = treeNode.i_val;
            this->p_left = treeNode.p_left;
            this->p_right = treeNode.p_right;
        }
        return *this;
    }
};

// 读到的字符是否是分隔符
inline bool isToken(char c, string &token)
{
    for(string::iterator it = token.begin(); it != token.end(); ++it)
    {
        if(c == (*it))
        {
            return true;
        }
    }
    return false;
}

// 读到的内容是否是数字
inline bool isNumber(string &str)
{
    if(str.size() == 0)
    {
        return false;
    }
    for(int i = 0; i < str.size(); ++i)
    {
        if(str[i] < '0' || str[i] > '9')
        {
            return false;
        }
    }
    return true;
}

// 字符串转数字
int str2int(string &str)
{
    int ret = 0;
    for(int i = 0; i < str.size(); ++i)
    {
        ret = ret * 10 + (str[i] - '0');
    }
    return ret;
}

// 从文件中读序列化后的内容
// 这里读到的内容是
// 30 10 50 # # # 20 45 # # 35 # #
vector<string> readFile(ifstream &in, string &token)
{
    if(!in.is_open())
    {
        cout << "Error during opening the file." << endl;
        exit(1);
    }
    char c;
    string word;
    vector<string> vec_Str;
    while(in.get(c))
    {
        if(!isToken(c, token))
        {
            word.push_back(c);
            continue;
        }

        if(word.length() > 0)
        {
            vec_Str.push_back(string(word.begin(), word.end()));
            word.clear();
        }
    }
    if(word.length() > 0)
    {
        vec_Str.push_back(string(word.begin(), word.end()));
    }

    return vec_Str;
}

// 反序列化二叉树
TreeNode *DeserializeTree(int &cur, vector<string> &vec_SerialTree)
{
    if(cur < 0 || cur >= vec_SerialTree.size() || vec_SerialTree.size() == 0 || !isNumber(vec_SerialTree[cur]))
    {
        return 0;
    }
    TreeNode *p_Node = new TreeNode(str2int(vec_SerialTree[cur]));
    cur = cur + 1;
    p_Node->p_left = DeserializeTree(cur, vec_SerialTree);
    cur = cur + 1;
    p_Node->p_right = DeserializeTree(cur, vec_SerialTree);

    return p_Node;
}

// 序列化二叉树
void SerializeTree(TreeNode *p_Root, ostream &out)
{
    if(!p_Root)
    {
        out << "# ";
    }
    else
    {
        out << p_Root->i_val << " ";
        SerializeTree(p_Root->p_left, out);
        SerializeTree(p_Root->p_right, out);
    }
}

// 释放资源
void DestroyTree(TreeNode **p_Root)
{
    if(!p_Root || !(*p_Root))
    {
        return;
    }
    DestroyTree(&((*p_Root)->p_left));
    DestroyTree(&((*p_Root)->p_right));
    delete *p_Root;
    p_Root = 0;
}

int main()
{
    string token(" ");
    ifstream in("D:/Lab/clab/file/1.txt");
    ofstream out("D:/Lab/clab/file/2.txt");

    vector<string> vec_SerialTree = readFile(in, token);

    int cur = 0;
    TreeNode *p_Root = DeserializeTree(cur, vec_SerialTree);

    if(out)
    {
        SerializeTree(p_Root, out);
    }

    DestroyTree(&p_Root);

    return 0;
}