二叉树前序，中序，后续遍历（递归和非递归）

一个家庭成员之间的血缘继承关系构成了一颗树，尤其是独生子女的家庭，构成的是一棵二叉树。比如说，每个同学同时继承了爸爸和妈妈的血缘。请同学们以此为背景，以自己为树根，以血缘继承关系为变，生成一棵家庭血缘继承关系二叉树；另外，分别用前序、中序和后序遍历访问家庭成员。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#define OK          1
#define ERROR       0
#define TRUE        1
#define FALSE       0
#define OVERFLOW   -2
#define INITSTACKSIZE 100
#define INCREASESIZE 10
typedef int Status;
typedef char TElemTye;
typedef struct BiTNode
{
TElemTye name[10];
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
typedef struct Stack
{
BiTree *top, *base;
int stacksize;
}Stack;
Status InitStack(Stack &S)
{
S.stacksize = INITSTACKSIZE;
S.base = (BiTree*)malloc(sizeof(BiTNode)*INITSTACKSIZE);
if (!S.base)
exit(OVERFLOW);
S.top = S.base;
return OK;
}
Status StackEmpty(Stack S)
{
if (S.base == S.top)
return OK;
return FALSE;
}
Status Push(Stack &S, BiTree a)
{
if (S.top - S.base >= S.stacksize)
{
S.base = (BiTree*)realloc(S.base, INCREASESIZE + S.stacksize);
if (!S.base)
exit(OVERFLOW);
S.stacksize += INCREASESIZE;
}
*S.top = a;
S.top++;
return OK;
}
Status Pop(Stack &S, BiTree &a)
{
if (S.base == S.top)
return ERROR;
S.top--;
a = *S.top;
return OK;
}
BiTree GetTop(Stack S, BiTree a)
{
if (S.base == S.top)
return ERROR;
a = *--S.top;
return a;
}
Status Stack_Size(Stack S)
{
int n;
n = S.top - S.base - 1;
return n;
}
Status CreateBiTree(BiTree &T)
{
char a[10];
gets_s(a);
if (strlen(a) == 0)
T = NULL;
else
{
T = (BiTree)malloc(sizeof(BiTNode));
if (!T)
return OVERFLOW;
strcpy_s(T->name, sizeof(T->name), a);
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return OK;
}
//递归先序遍历
Status RePreOrderTraverse(BiTree &T)
{
if (T)
{
printf("%s\n", T->name);
RePreOrderTraverse(T->lchild);
RePreOrderTraverse(T->rchild);
}
return OK;
}
//非递归先序遍历
Status URePreOrderTraverse(BiTree T)
{
Stack S;
InitStack(S);
BiTree p;
p = T;
while (!StackEmpty(S) || p)
{
if (p)
{
printf("%s\n", p->name);
Push(S, p);
p = p->lchild;
}
else
{
Pop(S, p);
p = p->rchild;
}
}
return OK;
}
//递归中序遍历
Status ReInOrderTraverse(BiTree &T)
{
if (T)
{
RePreOrderTraverse(T->lchild);
printf("%s\n", T->name);
RePreOrderTraverse(T->rchild);
}
return OK;
}
//非递归中序遍历
Status UReInOrderTraverse(BiTree T)
{
BiTree p;
Stack S;
InitStack(S);
p = T;
while (!StackEmpty(S) || p)
{
if (p)
{
Push(S, p);
p = p->lchild;
}
else
{
Pop(S, p);
printf("%s\n", p->name);
p = p->rchild;
}
}
return OK;
}
//递归后续遍历
Status RePostOrderTraverse(BiTree &T)
{
if (T)
{
RePreOrderTraverse(T->lchild);
RePreOrderTraverse(T->rchild);
printf("%s\n", T->name);
}
return OK;
}
//非递归后序遍历
Status URePostOrderTraverse(BiTree T)
{
BiTree p;
Stack S;
InitStack(S);
p = T;
int Tag[20];      //栈，用于标识从左（0）或右（1）返回
while (p != NULL || !StackEmpty(S))
{
while (p != NULL)
{
Push(S, p);
Tag[Stack_Size(S)] = 0;
p = p->lchild;
}
while (!StackEmpty(S) && Tag[Stack_Size(S)] == 1)
{
Pop(S,p);
printf("%s\n", p->name);
}
if (!StackEmpty(S))
{
Tag[Stack_Size(S)] = 1;   //设置标记右子树已经访问
p = GetTop(S,p);
p = p->rchild;
}
else break;
}

return OK;
}
int main()
{
BiTree T;
CreateBiTree(T);
printf("递归先序遍历\n");
RePreOrderTraverse(T);
printf("非递归先序遍历\n");
URePreOrderTraverse(T);
printf("递归先中序遍历\n");
ReInOrderTraverse(T);
printf("非递归中序遍历\n");
UReInOrderTraverse(T);
printf("递归后序遍历\n");
RePostOrderTraverse(T);
printf("非递归后序遍历\n");
URePostOrderTraverse(T);
return 0;
}