二叉树四种遍历（前序、中序、后序、层序）

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

struct BiTreeNode
{
    char data;
    BiTreeNode *Lchd;
    BiTreeNode *Rchd;
};

// 前序创建二叉树
BiTreeNode* CreateTree()
{
    char input;
    cin >> input;
    if(input == '0')
        return NULL;
    else
    {
        BiTreeNode *node = new BiTreeNode;
        node->data = input;
        node->Lchd = CreateTree();
        node->Rchd = CreateTree();
        return node;
    }
}

// 递归前序遍历
void PreOrderTraversal(BiTreeNode *root)
{
    if(root)
    {
        cout << root->data << ' ';
        PreOrderTraversal(root->Lchd);
        PreOrderTraversal(root->Rchd);
    }

}

// 非递归前序遍历
void PreOrderTraversalNoRec(BiTreeNode *root)
{
    stack<BiTreeNode*> S;
    BiTreeNode *p = root;

    while(p != NULL || S.empty() == false)
    {
        while(p != NULL)
        {
            cout << p->data << ' ';
            S.push(p);
            p = p->Lchd;
        }
        if(!S.empty())
        {
            p = S.top();
            S.pop();
            p = p->Rchd;
        }
    }
}

// 递归中序遍历
void InOrderTraversal(BiTreeNode *root)
{
    if(root)
    {
        InOrderTraversal(root->Lchd);
        cout << root->data << ' ';
        InOrderTraversal(root->Rchd);
    }
}

// 非递归中序遍历
void InOrderTraversalNoRec(BiTreeNode *root)
{
    stack<BiTreeNode*> S;
    BiTreeNode *p = root;

    while(p != NULL || !S.empty())
    {
        while(p != NULL)
        {
            S.push(p);
            p = p->Lchd;
        }
        if(!S.empty())
        {
            p = S.top();
            cout << p->data << ' ';
            S.pop();
            p = p->Rchd;
        }
    }
}

// 递归后序遍历
void PostOrderTraversal(BiTreeNode *root)
{
    if(root)
    {
        PostOrderTraversal(root->Lchd);
        PostOrderTraversal(root->Rchd);
        cout << root->data << ' ';
    }
}

// 非递归后序遍历
void PostOrderVisitNoRec(BiTreeNode *root)
{
    stack<BiTreeNode*> S;
    BiTreeNode *p = root;
    BiTreeNode *LastVisited = NULL;

    while(p != NULL || !S.empty())
    {
        while(p != NULL)
        {
            S.push(p);
            p = p->Lchd;
        }
        p = S.top();
        if(p->Rchd == NULL || p->Rchd == LastVisited)
        {
            cout << p->data << ' ';
            LastVisited = p;
            p = NULL;
            S.pop();
        }
        else
            p = p->Rchd;
    }
}

// 层序遍历
void LevelOrderTraversal(BiTreeNode *root)
{
    queue<BiTreeNode*> Q;
    BiTreeNode *p = root;

    if(p)
    {
        Q.push(p);
        while(!Q.empty())
        {
            p = Q.front();
            Q.pop();
            cout << p->data << ' ';
            if(p->Lchd)
                Q.push(p->Lchd);
            if(p->Rchd)
                Q.push(p->Rchd);
        }
    }

}

int main()
{
    BiTreeNode *root = NULL;
    root = CreateTree();

    cout << "PreOrder:" << endl;
    PreOrderTraversal(root);
    cout << endl;
    PreOrderTraversalNoRec(root);
    cout << endl << endl;

    cout << "InOrder:" << endl;
    InOrderTraversal(root);
    cout << endl;
    InOrderTraversalNoRec(root);
    cout << endl << endl;

    cout << "PostOrder:" << endl;
    PostOrderTraversal(root);
    cout << endl;
    PostOrderTraversal(root);
    cout << endl << endl;

    cout << "LevelOrder:" << endl;
    LevelOrderTraversal(root);
    cout << endl;
    return 0;
}