二叉树的一系列基本操作

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef char ElemType;


typedef struct node
{
    ElemType data;
    struct node *lchild;
    struct node *rchild;
}BTNode;


typedef struct
{
    BTNode *data[MaxSize];
    int front,rear;//队头和队尾指针
}SqQueue;//顺序队类型


typedef struct{
    BTNode *data[MaxSize];
    int top;
}SqStack;




void InitStack(SqStack *&st)
{
    st=(SqStack *)malloc(sizeof(SqStack));
    st->top=-1;
}//初始化栈




void DestroyStack(SqStack *&st)
{
    free(st);
}//销毁栈


bool StackEmpty(SqStack *st)
{
    return (st->top==-1);
}//判断栈是否为空


bool Push(SqStack *&st,BTNode *e)
{
    if(st->top==MaxSize-1)//判断是否会溢出
        return false;
    st->top++;
    st->data[st->top]=e;
    return true;
}//入栈


bool Pop(SqStack *&st,BTNode *&e)
{
    if(st->top==-1)
        return false;
    e=st->data[st->top];
    st->top--;
    return true;
}//出栈


bool GetTop(SqStack *st,BTNode *&e)
{
    if(st->top==-1)
        return false;
    e=st->data[st->top];
    return true;
}//取栈顶元素


void InitQueue(SqQueue *&qu)
{
    qu=(SqQueue *)malloc(sizeof(SqQueue));
    qu->front=qu->rear=0;
}//初始化队列


void DestroyQueue(SqQueue *&qu)
{
    free(qu);
}//销毁队列


bool QueueEmpty(SqQueue *qu)
{
    return (qu->front==qu->rear);//队空的条件
}


bool enQueueEmpty(SqQueue *&qu,BTNode *e)
{
    if((qu->rear+1)%MaxSize==qu->front)
        return false;
    qu->rear=(qu->rear+1)%MaxSize;
    qu->data[qu->rear]=e;
    return true;
}//进队列


bool deQueue(SqQueue *&qu,BTNode *&e)
{
    if(qu->front==qu->rear)
        return false;
    qu->front=(qu->front+1)%MaxSize;
    e=qu->data[qu->front];
    return true;
}//出队列


void CreateBTree(BTNode *&b,char *str)
{
    BTNode *St[MaxSize],*p;
    int top=-1,k,j=0;
    char ch;
    b=NULL;
    ch=str[j];
    while(ch!='\0')
    {
        switch(ch)
        {
            case'(':top++;St[top]=p;k=1;break;
            case')':top--;break;
            case',':k=2;break;
            default:p=(BTNode *)malloc(sizeof(BTNode));
                    p->data=ch;
                    p->lchild=p->rchild=NULL;
                    if(b==NULL)
                        b=p;
                    else
                    {
                        switch(k)
                        {
                            case 1:St[top]->lchild=p;break;
                            case 2:St[top]->rchild=p;break;
                        }
                    }
        }
         j++;
        ch=str[j];
    }
}//创建二叉树


void DestroyBTree(BTNode *&b)
{
    if(b!=NULL)
    {
        DestroyBTree(b->lchild);
        DestroyBTree(b->rchild);
        free(b);
    }
}//销毁二叉树


BTNode *FindNode(BTNode *b,ElemType x)
{
    BTNode *p;
    if(b==NULL)
        return NULL;
    else if(b->data==x)
        return b;
    else
    {
        p=FindNode(b->lchild,x);
        if(p!=NULL)
            return p;
        else
            return FindNode(b->rchild,x);
    }
}//查找结点


BTNode *lchildNode(BTNode *p)
{
    return p->lchild;
}


BTNode *rchildNode(BTNode *p)
{
    return p->rchild;
}


int BTHeight(BTNode *b)
{
    int lchildh,rchildh;
    if(b==NULL) return (0);
    else
    {
        lchildh=BTHeight(b->lchild);
        rchildh=BTHeight(b->rchild);
        return (lchildh>rchildh)?(lchildh+1):(rchildh+1);
    }
}//求高度


int Nodes(BTNode *b)
{
    if(b==NULL) return 0;
    else
        return Nodes(b->lchild)+Nodes(b->rchild)+1;
}//二叉树的节点数目


void DispLeaf(BTNode *b)
{
    if(b!=NULL)
    {
        if(b->lchild==NULL&&b->rchild==NULL)
            printf("%c",b->data);
        DispLeaf(b->lchild);
        DispLeaf(b->rchild);
    }
}//二叉树叶子节点


int BTreeLeaf(BTNode *b)
{
    if(b==NULL) return 0;
    else
    {
    if(b->lchild==NULL&&b->rchild==NULL) return 1;
    else return BTreeLeaf(b->lchild)+BTreeLeaf( b->rchild);
    }
}//二叉树叶子节点个数


void DispBTree(BTNode *b)
{
    if(b!=NULL)
    {
        printf("%c",b->data);
        if(b->lchild!=NULL || b->rchild!=NULL)
        {
            printf("(");
            DispBTree(b->lchild);
            if(b->rchild!=NULL) printf(",");
            DispBTree(b->rchild);
            printf(")");
        }
    }
}//输出二叉树


void PreOrder(BTNode *b)
{
    if(b!=NULL)
    {
        printf("%C",b->data);
        PreOrder(b->lchild);
        PreOrder(b->rchild);
    }
}//先序遍历递归


void InOrder(BTNode *b)
{
    if(b!=NULL)
    {
        InOrder(b->lchild);
        printf("%C",b->data);
        InOrder(b->rchild);
    }
}//中序遍历递归


void PostOrder(BTNode *b)
{
    if(b!=NULL)
    {
        PostOrder(b->lchild);
        PostOrder(b->rchild);
        printf("%C",b->data);
    }
}//中序遍历递归


void PreOrder1(BTNode *b)
{
    BTNode *p;
    SqStack *st;
    InitStack(st);
    if(b!=NULL)
    {
        Push(st,b);
        while(!StackEmpty(st))
        {
            Pop(st,p);
            printf("%c",p->data);
            if(p->rchild!=NULL)
                Push(st,p->rchild);
            if(p->lchild!=NULL)
                Push(st,p->lchild);
        }
        printf("\n");
    }
    DestroyStack(st);
}//先序遍历非递归1


void PreOrder2(BTNode *b)
{
    BTNode *p;
    SqStack *st;
    InitStack(st);
    p=b;
    while(!StackEmpty(st)||p!=NULL)
    {
        while(p!=NULL)
        {
            printf("%c",p->data);
            Push(st,p);
            p=p->lchild;
        }
        if(!StackEmpty(st))
        {
            Pop(st,p);
            p=p->rchild;
        }
    }
    printf("\n");
    DestroyStack(st);
}//先序遍历非递归2


void InOrder1(BTNode *b)
{
    BTNode *p;
    SqStack *st;
    InitStack(st);
    p=b;
    while(!StackEmpty(st)||p!=NULL)
    {
        while(p!=NULL)
        {
            Push(st,p);
            p=p->lchild;
        }
        if(!StackEmpty(st))
        {
            Pop(st,p);
            printf("%c",p->data);
            p=p->rchild;
        }
    }
    printf("\n");
    DestroyStack(st);
}//中序遍历非递归


void PostOrder1(BTNode *b)
{
    BTNode *p,*r;
    bool flag;
    SqStack *st;
    InitStack(st);
    p=b;
    do
    {
        while(p!=NULL)
        {
            Push(st,p);
            p=p->lchild;
        }
        r=NULL;
        flag=true;
        while(!StackEmpty(st)&&flag)
        {
            GetTop(st,p);
            if(p->rchild==r)
            {
                printf("%c",p->data);
                Pop(st,p);
                r=p;
            }
            else
            {
                p=p->rchild;
                flag=false;
            }
        }
    }while(!StackEmpty(st));
    printf("\n");
    DestroyStack(st);
}//后序遍历非递归


void LevelOrder(BTNode *b)
{


    BTNode *p;
    SqQueue *qu;
    InitQueue(qu);
    enQueueEmpty(qu,b);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,p);
        printf("%c",p->data);
        if(p->lchild!=NULL)
            enQueueEmpty(qu,p->lchild);
        if(p->rchild!=NULL)
            enQueueEmpty(qu,p->rchild);
    }
}//层次遍历


int main()
{
    BTNode *b;
    BTNode *p;
    char *str="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I))))";
    CreateBTree(b,str);
    DispBTree(b);
    printf("\n");
    printf("二叉树的节点个数：");
    printf("%d\n",Nodes(b));
    BTNode *c;
    c=lchildNode(FindNode(b,'H'));
    printf("H的左孩子值：");
    printf("%c\n",c->data);
    BTNode *d;
    d=rchildNode(FindNode(b,'H'));
    printf("H的右孩子值：");
    printf("%c\n",d->data);
    printf("二叉树的高度：");
    printf("%d\n",BTHeight(b));
    printf("二叉树的叶子节点：");
    DispLeaf(b);
    printf("\n");
    printf("二叉树的叶子节点个数：");
    printf("%d\n",BTreeLeaf(b));
    printf("二叉树先序遍历递归：");
    PreOrder(b);
    printf("\n");
    printf("二叉树先序遍历非递归1：");
    PreOrder1(b);
    printf("二叉树先序遍历非递归2：");
    PreOrder2(b);
    printf("二叉树中序遍历递归：");
    InOrder(b);
    printf("\n");
    printf("二叉树中序遍历非递归：");
    InOrder1(b);
    printf("二叉树后序遍历递归：");
    PostOrder(b);
    printf("\n");
    printf("二叉树后序遍历非递归：");
    PostOrder1(b);
    printf("二叉树层次遍历非递归：");
    LevelOrder(b);
    return 0;
}