键指offer || 序列化和反序列化二叉树（非递归实现）

本人小菜鸡一枚，不喜勿喷。欢迎大佬指正。

题目：序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

这里分析一下题目的意思就是说，提供一个方法将一颗二叉树转换成字符串来进行存储。并能通过另一个方式就这串字符串还原成对应的二叉树。

class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        stack<TreeNode*> stk;
        stk.push(root);
        string s;
        while(!stk.empty()){
            TreeNode* temp = stk.top();
            stk.pop();
            if(temp ==  NULL){
                s += "#,";
                continue;
            } else {
                s += to_string(temp->val) + ",";
            }
            stk.push(temp->right);
            stk.push(temp->left);
        }
        return s;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        stack<TreeNode*> stk;
        queue<int> que;
        stack<int> _num;
        string s;
        for(char c: data){
            if(c == ','){
                if(s == "#") que.push(1001);
                else  que.push(stoi(s));
                s.clear();
            } else {
                s.push_back(c);
            }
        }
        if(que.front() == 1001) return NULL;
        TreeNode* ans = new TreeNode(que.front());
        stk.push(ans);
        _num.push(0);
        que.pop();
        while(!stk.empty()){
            int num = que.front();
            que.pop();
            if(num == 1001){
                TreeNode* temp = stk.top();
                stk.pop();
                int num2 = _num.top();
                _num.pop();
                if(num2 == 0){
                    temp->left = NULL;
                } else {
                    temp->right == NULL;
                    continue;
                }
                num = que.front();
                que.pop();
                if(num == 1001){
                    temp->right = NULL;
                } else {
                    TreeNode* t2 = new TreeNode(num);
                    temp->right = t2;
                    stk.push(t2);
                    _num.push(0);
                }
            } else {
                TreeNode* temp = new TreeNode(num);
                int num1 = _num.top();
                _num.pop();
                if(num1 == 0){
                    stk.top()->left = temp;
                    num1++;
                    _num.push(num1);
                } else {
                    stk.top()->right = temp;
                    stk.pop();
                }
                stk.push(temp);
                _num.push(0);
            }
        }
        return ans;
    }
};

这里虽然说是用了非递归实现，但因为本人的能力原因，代码代码并没有写好，而是相当于有了一种暴力解法的感觉在里面。