【二叉树】二叉树的相关操作

递归实现：

1. 创建
2. 求树高
3. 求叶子数
4. 求节点数
5. 统计度为2的结点个数
6. 后序输出 先序输出 中序输出
7. 交换左右子树

#include <stdlib.h>
#include <malloc.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define NULL 0
typedef int Status;

// 二叉树存储结构定义 
// 二叉链表存储结构
typedef int TElemType;
typedef struct BiTNode{
    TElemType data;
    struct BiTNode * lchild;
    struct BiTNode * rchild;
}BiTNode, *BiTree;

// 创建二叉树
// 输入0 代表创建空树
// 递归创建 
// 递归边界：创建空树
// 递归关系：创建非空树，先创建根节点(输入数值)，再创建左子树，最后创建右子树
Status CreateBiTree(BiTree& T){
    TElemType e;
    scanf("%d", &e);
    if(e == 0)
        T = NULL;
    else{
        T = (BiTree)malloc(sizeof(BiTNode));
        if(!T) exit(OVERFLOW);
        T->data = e;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return OK;
}

// 求树高
// 如果是空树，返回0
// 递归求树高
// 递归边界：当前树为空
// 递归关系：返回当前节点 左右子树中更高的+1 (根节点)
int GetDepthOfBiTree(BiTree T){
    if(!T)
        return 0;
    else{
        int d1 = GetDepthOfBiTree(T->lchild);
        int d2 = GetDepthOfBiTree(T->rchild);
        return d1>d2?d1+1:d2+1;
    }
}

// 求叶子节点数
// 如果是空树 返回0
// 递归求叶子数
// 递归边界：当前节点左右子树为空，返回1
// 递归关系：左子树叶子数 + 右子树叶子数
int LeafCount(BiTree T){
    if(!T)
        return 0;
    if(!T->rchild && !T->lchild)
        return 1;
    else 
        return LeafCount(T->lchild) + LeafCount(T->rchild);
}

// 计算二叉树中的节点个数
// 如果是空树 返回0
// 递归求节点数
// 递归边界：当前树为空
// 递归关系：左子树结点数 + 右子树结点数 + 1(根节点)
int NodeCountOfBiTree ( BiTree T){
    if(!T)
        return 0;
    else
        return 1 + NodeCountOfBiTree(T->lchild) + NodeCountOfBiTree(T->rchild);
}

// 统计度为2的结点个数
// 如果树为空 返回0
// 递归求 
// 递归边界：树为空
// 递归关系：左右子树都存在，返回 1+递归；一个或不存在 返回 递归
int NodeCount ( BiTree T){
    if(!T)
        return 0;
    else if(T->lchild && T->rchild)
        return 1 + NodeCount(T->lchild) + NodeCount(T->rchild);
    else
        return NodeCount(T->lchild) + NodeCount(T->rchild);
}

// 左右子树交换
// 如果树为空，直接返回
// 递归交换
// 递归边界：树为空
// 递归关系：递归交换左右子树
void ExChangeTree(BiTree& T){
    if(!T)
        return ;
    else{
        BiTNode * t = (BiTNode*)malloc(sizeof(BiTree));
        t = T->rchild;
        T->rchild = T->lchild;
        T->lchild = t;
        ExChangeTree(T->lchild);
        ExChangeTree(T->rchild);
    }
}

// 后序输出
// 递归边界：数为空，直接返回
// 递归关系：依次递归遍历左子树、右子树
void PostOrder(BiTree T){
    if(!T)
        return ;
    else{
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        printf("%d ", T->data);
    }
}
// 先序输出
void PreOrder(BiTree T){
    if(!T)
        return ;
    else{
        printf("%d ", T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}
// 中序输出
void InOrder(BiTree T){
    if(!T)
        return ;
    else{
        PreOrder(T->lchild);
        printf("%d ", T->data);
        PreOrder(T->rchild);
    }
}

int main()
{
    BiTree T;
    CreateBiTree(T);
    printf("%d\n", GetDepthOfBiTree(T));
    printf("%d\n", LeafCount(T));
    printf("%d\n", NodeCountOfBiTree(T));
    printf("%d\n", NodeCount(T));
    PostOrder(T); printf("\n");
    PreOrder(T);  printf("\n");
    InOrder(T);   printf("\n");
    printf("\n");
    ExChangeTree(T);
    PostOrder(T); printf("\n");
    PreOrder(T);  printf("\n");
    InOrder(T);   printf("\n");

    return 0;
}