二叉树——基本操作

// A code block
二叉树的一些基本操作

 1. 层序遍历
 2. 先序遍历
 3. 后序遍历
 4. 中序遍历
 5. 倒叙遍历
 6. 求树高
 7. 求叶子节点数

// An highlighted block
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#define MAXSIZE 60          
#define datatype char
struct Tree         //二叉树
{
    Tree *lchild;
    Tree *rchild;
    datatype data;
    /* data */
};
struct Queue            //队列
{
    Tree *data[MAXSIZE];
    int front;
    int rear;
    /* data */
};
struct Stack
{
    Tree *data[MAXSIZE];
    int top;
    /* data */
};

int LeafNodeNum = 0;                    //叶子节点个数

void GetNumLeafNode(Tree *tree);        //获取叶子节点的个数
void ShowNode(Tree *tree);              //中序遍历二叉树
void RearShow(Tree *tree);              //后序遍历
void PirorShow(Tree *tree);             //先序遍历
int GetHeight(Tree *tree);              //求树高
void LayerShow(Tree *tree);             //层序遍历

bool EnQueue(Queue &queue,Tree *tree);  //出队列
Tree *ExQueue(Queue &queue);            //入队列
Queue CreateQueue();                    //创建并初始化队列
Tree *CreateBTree();                    //创建二叉树
int max(int n,int m);                   //求两数最大值    
void InitStack(Stack &stack);           //初始化栈
Tree *PopStack(Stack &stack);           //出栈
bool PushStack(Stack &stack,Tree *tree);//入栈
void ShowStack(Stack stack);            //遍历栈
void OverLayerShow(Tree *tree);         //倒序遍历


void ShowStack(Stack stack){
    while(stack.top!=-1){
        Tree *node = stack.data[stack.top--];
        printf("%c\t",node->data);
    }
}
void InitStack(Stack &stack){
    stack.top = -1;
}
Tree *PopStack(Stack &stack){
    if(stack.top == -1)
        return NULL;
    return stack.data[stack.top--];
}
bool PushStack(Stack &stack,Tree *tree){
    if(stack.top == MAXSIZE -1)
        return false;
    stack.data[++stack.top] = tree;
    return true;
}
int max(int n,int m){                   //求两数最大值
    return n>m?n:m;
}
Tree *CreateBTree()     //根据先序创建二叉树，为空的节点用#表示
{
    Tree *bt = NULL;
    char ch;
    scanf("%c", &ch);
    if (ch != '#')
    {
        bt = (Tree*)malloc(sizeof(Tree));
        bt->data = ch;
        bt->lchild = CreateBTree();
        bt->rchild = CreateBTree();
    }
    return bt;
}
void GetNumLeafNode(Tree *tree){

    if(!tree)
        return;
    if(tree->rchild ==NULL && tree->lchild ==NULL)
        LeafNodeNum++;
    GetNumLeafNode(tree->lchild);
    GetNumLeafNode(tree->rchild);
}

void ShowNode(Tree *tree){                      //中序遍历二叉树
    if(!tree)
        return;
    ShowNode(tree->lchild);
    printf("%c\t",tree->data);
    ShowNode(tree->rchild);
}
void RearShow(Tree *tree){      //后序遍历

    if(!tree)
        return ;

    RearShow(tree->lchild);
    RearShow(tree->rchild);
    printf("%c\t",tree->data);
}
void PirorShow(Tree *tree){      //先序遍历

    if(!tree)
        return ;
    printf("%c\t",tree->data);
    RearShow(tree->lchild);
    RearShow(tree->rchild);
}
int GetHeight(Tree *tree){        //求树高

    if(!tree)
        return 0;
    return max(GetHeight(tree->lchild),GetHeight(tree->rchild)) + 1;

}
bool EnQueue(Queue &queue,Tree *tree){      //入队列
    if((queue.rear+1)%MAXSIZE == queue.front)
        return false;
    queue.data[queue.rear] = tree;
    queue.rear = (queue.rear+1)%MAXSIZE;
    return true;
}
Tree *ExQueue(Queue &queue){                //出队列
    if(queue.rear == queue.front)
        return NULL;
    Tree *node = queue.data[queue.front];
    queue.front = (queue.front+1)%MAXSIZE;
    return node;
}
Queue CreateQueue(){                    //创建并初始化队列
    Queue queue;
    queue.front = queue.rear = -1;
    return queue;
}
void LayerShow(Tree *tree){             //层序遍历
    Queue queue = CreateQueue();
    EnQueue(queue,tree);
    while(queue.front!=queue.rear){
        Tree *node = ExQueue(queue);
        printf("%c\t",node->data);
        if(node->lchild!=NULL){
            EnQueue(queue,node->lchild);
        }
        if(node->rchild!=NULL){
            EnQueue(queue,node->rchild);
        }
    }
}
void OverLayerShow(Tree *tree){             //倒序遍历
    Stack stack;
    InitStack(stack);
    Queue queue = CreateQueue();
    EnQueue(queue,tree);
    while(queue.front!=queue.rear){
        Tree *node = ExQueue(queue);
        PushStack(stack,node);
        if(node->lchild!=NULL){
            EnQueue(queue,node->lchild);
        }
        if(node->rchild!=NULL){
            EnQueue(queue,node->rchild);
        }
    }
    ShowStack(stack);                   //输出栈
}
int main(){

    Tree *Root;
    Root = CreateBTree();
    ShowNode(Root);
    printf("\n");
    LayerShow(Root);
    printf("\n Reverse Show: ");
    OverLayerShow(Root);
    GetNumLeafNode(Root);
    printf("\n LeafNodeNum:%d",LeafNodeNum);
    printf("\n Height:%d\n",GetHeight(Root));
    system("pause");
    return 0;
}

/*
            A
        B       C
    D     E  F      G
H     I         J

先序遍历：ABDH##I##E##CF#J##G##

*/