二叉树基本操作及树形打印

include

include

define INIT_STACK_SIZE 100

define STACKINCREMENT 10

typedef char ElemType;
typedef struct BiTnode{
ElemType data;
struct BiTnode *lchild,*rchild;
int visitcount; //非递归后序遍历使用
}BiTnode,*BiTree;//定义二叉树存储表示

//定义栈//
typedef struct{
BiTnode **base;
BiTnode **top;
int stacksize;
}SqStack;
//初始化栈//
void InitStack(SqStack &S)
{
if (!(S.base = (BiTnode *)malloc(sizeof(BiTree) INIT_STACK_SIZE)))
return;
S.top = S.base;
S.stacksize = INIT_STACK_SIZE;
return;
}
//元素进栈//
void Push(SqStack &S, BiTnode *e)
{
if (S.top - S.base >= S.stacksize)
{
if (!(S.base = (BiTnode *)realloc(S.base, sizeof(BiTree) (STACKINCREMENT + S.stacksize))))
return;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return;
}
//元素出栈//
void Pop(SqStack &S, BiTnode **e)
{
if (S.base == S.top)
return;
e = –S.top;
return;
}
//取栈顶元素//
int GetTop(SqStack S, BiTnode **e)
{
if (S.base == S.top)
return 0;
e = (S.top - 1);
return 1;
}
//判断栈是否为空//
int StackEmpty(SqStack S)
{
if (S.top == S.base)
return 1;
else
return 0;
}

void CreatTree(BiTree &T)//建立二叉树
{
char ch;
scanf(“%c”,&ch);
if(ch==’ ‘)
{
T=NULL;
}
else{
T=(BiTnode*)malloc(sizeof(BiTnode));
T->data=ch;
CreatTree(T->lchild);
CreatTree(T->rchild);
}

}
void Preorder_traversal(BiTnode *T)//递归先序遍历
{
if(T)
{
printf(“%c”,T->data);
if(T->lchild)
Preorder_traversal(T->lchild);
if(T->rchild)
Preorder_traversal(T->rchild);
}
}
void Inorder_traversal(BiTnode *T)//递归中序遍历
{
if(T)
{
if(T->lchild)
Inorder_traversal(T->lchild);
printf(“%c”,T->data);
if(T->rchild)
Inorder_traversal(T->rchild);
}
}
void Postorder_traversal(BiTnode *T)//递归后序遍历
{
if(T)
{
if(T->lchild)
Postorder_traversal(T->lchild);
if(T->rchild)
Postorder_traversal(T->rchild);
printf(“%c”,T->data);
}
}

void preorder_traversal(BiTree T)//非递归先序遍历
{
BiTree p;
SqStack S;
InitStack(S);
Push(S, T); //根指针进栈
while(!StackEmpty(S))
{
while(GetTop(S, &p) && p)
{
printf(“%c”, p->data);
Push(S, p->lchild);
}
Pop(S, &p); //空指针退栈
if(!StackEmpty(S))
{
Pop(S, &p); //根结点出栈
Push(S,p->rchild); //右孩子进栈
}
}

return;

}

void inorder_traversal(BiTree T)//非递归中序遍历
{
SqStack S;
BiTree p;
InitStack(S);
Push(S,T);
while (!StackEmpty(S))
{
while (GetTop(S,&p) && p)
{
Push(S,p->lchild); //向左走到尽头
}
Pop(S,&p); //空指针退栈
if (!StackEmpty(S))
{
Pop(S,&p);
printf(“%c”, p->data);
Push(S,p->rchild);
}
}

return;

}

void postorder_traversal(BiTree T)//非递归后序遍历
{
SqStack S;
BiTree p = T;
InitStack(S);

while (p || !StackEmpty(S))
{
    if(p)
    {
        if (p->visitcount != 2)
        {
            p->visitcount = 1;
            Push(S, p);
        }
        p = p->lchild;
    }
    else
    {
        Pop(S, &p);
        if(p->visitcount == 2)
        {
            printf("%c", p->data);
        }
        else
        {
            p->visitcount++;
            Push(S, p);
        }
        p = p->rchild;
    }
}

return;

}

//递归求树的深度
int DepthofBiTree(BiTree T){
if (T==NULL)//空树
return 0;
int a = DepthofBiTree(T->lchild);
int b = DepthofBiTree(T->rchild);
return (a>b?a:b)+1;
}
//二叉树节点总数目
int BiTNodenum(BiTree T){
if(T == NULL)
{
return 0;
}
else
{
return 1+BiTNodenum(T->lchild)+BiTNodenum(T->rchild);
}
}
//树形打印二叉树
void PrintTree(BiTree &T,int h)
{
if(T==NULL)
return ;
PrintTree(T->rchild,h+1);
for(int i=0;i