二叉树创建以及遍历（递归和非递归方式）

#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;
}