#include <iostream>
#include <assert.h>
#include <stack>

using namespace std;

typedef struct biTreeNode
{
    char data;
    struct biTreeNode *lChild;
    struct biTreeNode *rChild;
}biTreeNode, *biTreePtr;


/********************************建立**********************************/

void
 
 create_preOrder_ptr(biTreePtr* tree)
{
    char ch;
//    cin >> ch;//C++風格,過濾掉空白字元(推薦)
    ch = getchar();//C語言風格,不會過濾掉空白字元(不推薦)
    if ('!' == ch)
        return;
    else
    {
        if (ch == '#')
            *tree = NULL;
        else
        {
            *tree = (biTreeNode*)malloc(sizeof(biTreeNode));
            assert(*tree != NULL);
            (*tree)->data = ch;
            create_preOrder_ptr(&((*tree)->lChild));
            create_preOrder_ptr(&((*tree)->rChild));
        }
    }
}

void
 
 create_preOrder_ref(biTreePtr &tree)
{
    char ch;
    cin >> ch;
    if ('!' == ch)
        return;
    else
    {
        if (ch == '#')
            tree = NULL;
        else
        {
            tree = (biTreeNode*)malloc(sizeof(biTreeNode));
            assert(tree != NULL);
            tree->data = ch;
            create_preOrder_ref(tree->lChild);
            create_preOrder_ref(tree->rChild);
        }
    }
}

void
 
 create_preOrder_val(biTreePtr tree)//值傳遞的方式無效
{
    char ch;
    cin >> ch;
    if ('!' == ch)
        return;
    else
    {
        if (ch == '#')
            tree = NULL;
        else
        {
            tree = (biTreeNode*)malloc(sizeof(biTreeNode));
            assert(tree != NULL);
            tree->data = ch;
            create_preOrder_val(tree->lChild);
            create_preOrder_val(tree->rChild);
        }
    }
}

/********************************三種遞迴遍歷方式**********************************/

//先序遍歷（遞迴）
void traverse_preOrder_ref(biTreePtr proot)
{
    if (proot)
    {
        cout << proot->data;
        traverse_preOrder_ref(proot->lChild);
        traverse_preOrder_ref(proot->rChild);
    }
}

//中序遍歷（遞迴）
void traverse_inOrder_ref(biTreePtr proot)
{
    if (proot)
    {
        traverse_inOrder_ref(proot->lChild);
        cout << proot->data;
        traverse_inOrder_ref(proot->rChild);
    }
}

//後序遍歷（遞迴）
void traverse_postOrder_ref(biTreePtr proot)
{
    if (proot)
    {
        traverse_postOrder_ref(proot->lChild);
        traverse_postOrder_ref(proot->rChild);
        cout << proot->data;
    }
}

/********************************三種非遞迴遍歷方式**********************************/

//先序遍歷（非遞迴）
void traverse_preOrder2(biTreeNode *proot)
{
    stack<biTreeNode*> stk;
    biTreeNode *p = proot;
    while(p != nullptr || !stk.empty())
    {
        while(p != nullptr)
        {
            cout << p->data << "";
            stk.push(p);
            p = p->lChild;
        }
        if(!stk.empty())
        {
            p = stk.top();
            stk.pop();
            p = p->rChild;
        }
    }
}

//中序遍歷（非遞迴）
void traverse_inorder2(biTreeNode *proot)
{
    stack<biTreeNode*> stk;
    biTreeNode *p = proot;
    while(p != nullptr || !stk.empty())
    {
        while(p != nullptr)
        {
            stk.push(p);
            p = p->lChild;
        }
        if(!stk.empty())
        {
            p = stk.top();
            cout << p->data << "";
            stk.pop();
            p = p->rChild;
        }
    }
}

//後序遍歷（非遞迴）

int main()
{
    //例：輸入AB##CD##E##,如果輸入不符合二叉樹要求,按回車鍵不會退出建立過程
    biTreePtr pTree = NULL;
    create_preOrder_ptr(&pTree);
    //create_preOrder_ref(tree);
    //create_preOrder_val(tree);//useless

    traverse_preOrder_ref(pTree);  cout << endl;
    traverse_preOrder2(pTree);     cout << endl;
    traverse_inOrder_ref(pTree);   cout << endl;
    traverse_inorder2(pTree);      cout << endl;
    traverse_postOrder_ref(pTree); cout << endl;

      return 0;
}