二叉树的非递归遍历以及序列化和反序列化

#include <iostream>
#include <queue>
#include <stack>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x):val(x),left(NULL),right(NULL){}
};
//二叉树的层次遍历,非递归
void LayerTraverse(TreeNode* root)
{
    if(root==nullptr)
        return;
    TreeNode* cur=nullptr;
    queue<TreeNode*> tmp;
    tmp.push(root);
    while(!tmp.empty())
    {
        cur=tmp.front();
        tmp.pop();
        cout<<cur->val<<" ";
        if(cur->left)
            tmp.push(cur->left);
        if(cur->right)
            tmp.push(cur->right);
    }
    cout<<endl;
}
//二叉树的前序遍历非递归
void PreOreder(TreeNode* root)
{
    if(root==nullptr) return;
    TreeNode* cur=nullptr;
    stack<TreeNode*> tmp;
    tmp.push(root);
    while(!tmp.empty())
    {
        cur=tmp.top();
        tmp.pop();
        cout<<cur->val<<" ";
        if(cur->right)
            tmp.push(cur->right);
        if(cur->left)
            tmp.push(cur->left);
    }
    cout<<endl;
}
//二叉树非递归中序遍历
void InOrder(TreeNode* root)
{
    if(root==nullptr) return;
    stack<TreeNode*> tmp;
    TreeNode* cur=root;
    while(!tmp.empty()||cur!=nullptr)
    {
        while(cur!=nullptr)
        {
            tmp.push(cur);
            cur=cur->left;
        }
        TreeNode* node=tmp.top();
        tmp.pop();
        cout<<node->val<<" ";
        cur=node->right;
    }
    cout<<endl;
}
//二叉树的非递归后续遍历
void houOrder(TreeNode* root)
{
    if(root==nullptr) return;
    TreeNode* cur=NULL;
    stack<TreeNode*> tmp1;
    tmp1.push(root);
    stack<TreeNode*> tmp2;
    while(!tmp1.empty())
    {
        cur=tmp1.top();
        tmp1.pop();
        tmp2.push(cur);
        if(cur->left)
            tmp1.push(cur->left);
        if(cur->right)
            tmp1.push(cur->right);
    }
    TreeNode* res=nullptr;
    while(!tmp2.empty())
    {
        res=tmp2.top();
        cout<<res->val<<" ";
        tmp2.pop();
    }
    cout<<endl;
}
//基于层序遍历的二叉树的序列化与反序列化
//序列化函数
void levelOrder(TreeNode*root, string &res) {
        if (!root)
            return;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()) {
            TreeNode* curr = q.front();
            q.pop();
            if (curr) {
                q.push(curr->left);
                q.push(curr->right);
                res += to_string(curr->val) + ',';
            } else {
                res += "$,";
            }
        }
    }
//反序列化函数
bool GetData(string & data,int& number);
TreeNode* deLayerOrder(string data)
{
    int number;
    if(data.empty()) return NULL;
    queue<TreeNode*> q;
    GetData(data,number);
    TreeNode* root=new TreeNode(number);
    TreeNode* cur=nullptr;
    q.push(root);
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        if(GetData(data,number))
        {
            cur->left=new TreeNode(number);
            q.push(cur->left);
        }
        if(GetData(data,number))
        {
            cur->right=new TreeNode(number);
            q.push(cur->right);
        }
    }
    return root;
}

bool GetData(string & data,int& number)
{
    number=0;
    int n=data.size();
    bool isnumber=true;
    bool negative=false;
    int i=0;
    while (i<n) {
        if(data[i]=='-')
        {
            negative=true;
            ++i;
        }
        else if(data[i]=='$')
        {
            isnumber=false;
            ++i;
        }
        else if(data[i]==',')
        {
            data=data.substr(i+1);
            if(negative) number=-number;
            return isnumber;
        }
        else
            number+=number*10+(data[i++]-'0');
    }
    return isnumber;
}


//序列化与反序列化的驱动函数

int main()
{
    cout << "Hello World!" << endl;
    TreeNode* node1=new TreeNode(1);
    TreeNode* node2=new TreeNode(2);
    TreeNode* node3=new TreeNode(3);
    TreeNode* node4=new TreeNode(4);
    TreeNode* node5=new TreeNode(5);
    TreeNode* node6=new TreeNode(6);
    TreeNode* node7=new TreeNode(7);
    node1->left=node2;
    node1->right=node3;
    node2->left=node4;
    node2->right=node5;
    node3->left=node6;
    node3->right=node7;
    LayerTraverse(node1);
    string str;
    levelOrder(node1,str);
    for(auto& t:str)
        cout<<t;
    cout<<endl;
    TreeNode* x=deLayerOrder(str);
    LayerTraverse(x);
    PreOreder(node1);
    InOrder(node1);
    houOrder(node1);
    return 0;
}