二叉树的遍历

#include<stdio.h>
#include<malloc.h>
#define M 25
struct BST
{
int Data;
BST *left;
BST *right;
};
BST *stack[M];//栈
int flag[M];//后序遍历中需要用到的标记数组
bool AddNodeToBST(BST* &Root, int Value)
{
if(Root == NULL)
{
BST *Node = (BST *)malloc(sizeof(BST));
if(!Node)
{
printf("内存分配失败\n");
return false;
}
Node->Data = Value;
Node->left = NULL;
Node->right = NULL;
Root = Node;
return true;
}
else if(Root->Data > Value)
AddNodeToBST(Root->left,Value);
else if(Root->Data < Value)
AddNodeToBST(Root->right, Value);
else
{
printf("重复加入节点\n");
return false;
}
}
void Destory(BST *Root)
{
if(!Root)
return;
Destory(Root->left);
Destory(Root->right);
free(Root);
Root = NULL;
}
//递归前序遍历，先根，再左，后右
void PreOrderRe(BST *Root)
{
if(!Root)
return;

printf("%d ",Root->Data);
PreOrderRe(Root->left);
PreOrderRe(Root->right);
}
//递归的中序遍历，先左，再根，后右
void MidOrderRe(BST *Root)
{
if(!Root)
return;
MidOrderRe(Root->left);
printf("%d ",Root->Data);
MidOrderRe(Root->right);
}
//递归的后序遍历，先左，再右，后根
void PostOrderRe(BST *Root)
{
if(!Root)
return;
PostOrderRe(Root->left);
PostOrderRe(Root->right);
printf("%d ", Root->Data);
}
void PreOrder(BST *Root)
{
if(!Root)
return;

BST *p;
int top = -1;
p = Root;

while(p != NULL || top > -1)
{
while(p != NULL)
{
printf("%d ",p->Data);
stack[++top] = p;
p = p->left;
}
//由于叶节点的左右都为空，所以遇到叶节点的时候会弹出两次。遇到左空，弹本身，遇到右空，弹出父节点
//三种遍历的思想是一样的
if(top > -1)
{
p = stack[top]->right;
--top;
}
}
printf("\n");
}
void MidOrder(BST *Root)
{
if(!Root)
return;
int top = -1;
BST *p = Root;

while(p != NULL || top > -1)
{
while(p != NULL)
{
stack[++top] = p;
p = p->left;
}
if(top > -1)
{
printf("%d ", stack[top]->Data);
p = stack[top]->right;
--top;
}
}
printf("\n");
}
void PostOrder(BST *Root)
{
int top = -1;
BST *p = Root;

while(p != NULL || top > -1)
{
while(p != NULL)
{
stack[++top] = p;
flag[top] = 0;
p = p->left;
}
while(top > -1 && flag[top])
{
printf("%d ", stack[top]->Data);
--top;
}
if(top > -1)
{
flag[top] = 1;
p = stack[top]->right;
}
}
printf("\n");
}
void main()
{
BST *Root = NULL;
int Value;
//输入数据
while(scanf("%d", &Value))
{
if(Value <= 0)
break;
AddNodeToBST(Root, Value);
}

PreOrderRe(Root);
printf("\n");
PreOrder(Root);

MidOrderRe(Root);
printf("\n");
MidOrder(Root);

PostOrderRe(Root);
printf("\n");
PostOrder(Root);

Destory(Root);
}

void LevelOrder(BST *Root)
{
if(!Root)
return;
int head = 1;
int tail = 1;
stack[tail] = Root;
flag[0] = 0;
flag[1] = 1;
while(head <= tail)
{
if(flag[head - 1] < flag[head])
printf("\n");
printf("%d ", stack[head]->Data);
if(stack[head]->left)
{
stack[++tail] = stack[head]->left;
flag[tail] = flag[head] + 1;
}
if(stack[head]->right)
{
stack[++tail] = stack[head]->right;
flag[tail] = flag[head] + 1;
}
++head;
}
printf("\n");
}