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

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