二叉树的构建、前中后层序遍历、深度、节点数、叶子节点数，子树转置

---

代码演示：

#include <stdio.h>
#include <stdlib.h>

#define MAX 20
#define NULL 0
#define OK   1
#define False 0


typedef char TElemType;
typedef int  Status;


typedef struct BiTNode{
    
    
    TElemType data;
    struct BiTNode *lchild, *rchild;
} BiTNode,*BiTree;

Status CreateBiTree(BiTree *T){
    
      // BiTNode T
    char ch;
    ch = getchar();
    if(ch=='#') (*T) = NULL;/// # 代表空指针
    else {
    
    
        (*T)=(BiTree)malloc(sizeof(BiTNode));
        (*T)->data=ch;///生成根结点
        CreateBiTree(&(*T)->lchild);///构造左子树
        CreateBiTree(&(*T)->rchild);///构造右子树
    }
    return OK;
}

// 先序遍历输出
Status PreOrder(BiTree T){
    
    
    if(T){
    
    
        printf("%2c",T->data);///T->data==(*T).data
        PreOrder(T->lchild);///先序遍历左子树
        PreOrder(T->rchild);///先序遍历右子树
        return OK;
    }
    return False;
}

// 中序遍历
Status InOrder (BiTree T) {
    
    
    if (T) {
    
    
        InOrder(T->lchild);
        printf("%2c",T->data);
        InOrder(T->rchild);
        return OK;
    }
    return False;
}


// 后序遍历
Status PostOrder (BiTree T) {
    
    
    if (T) {
    
    
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        printf("%2c",T->data);
        return OK;
    }
    return OK;
}



// 层次遍历二叉树T，从第一层开始，每层从左到右
Status LevelOrder(BiTree T){
    
    

    BiTree Queue[MAX],b;
    // 用一维数组表示队列，front和rear分别表示队首和队尾指针
    int front,rear;
    front=rear=0;
    if(T) {
    
        // 若树非空
        Queue[rear++]=T;// 根结点入队列
        while(front!=rear){
    
     // 当队列非空
            b=Queue[front++];// 队首元素出队列，并访问这个结点
            printf("%2c",b->data);
            if(b->lchild!=NULL){
    
    
                Queue[rear++]=b->lchild;
                // 左子树非空，则入队列
            }
            if(b->rchild!=NULL){
    
    
                Queue[rear++]=b->rchild;
                // 右子树非空，则入队列
            }
        }
    }
}

// 求二叉树的深度
int depth(BiTree T) {
    
    
    int depL,depR; // 定义所有孩子深度
    if (T==NULL)  return False; // 空二叉树
    else {
    
    
        depL = depth(T->lchild);
        depR = depth(T->rchild);
        return depL > depR ? depL+1:depR+1;
    }
}

// 求二叉树节点数目: 结点个数 = 树的左子树结点，加右子树结点 + 根结点
int getNodeNUm(BiTree T){
    
    
    if (!T) return False;
    else {
    
    
     return getNodeNUm(T->lchild) + getNodeNUm(T->rchild) + 1;
    }
}

// 求叶子节点数目
int getLeafNodeNum(BiTree T){
    
    
    static LeafCount = 0; // 定义一个静态类型变量，完美解决 每次 递归都为 0 的情况
    if(!T) return False;
    else {
    
    
        getLeafNodeNum(T->lchild);
        getLeafNodeNum(T->rchild);
        if ((!T->lchild) && (!T->rchild)) {
    
     // 左右孩子不存在则是叶子节点
            LeafCount++;
        }
    }
    return LeafCount;
}

// 将二叉树每个结点的左右子树交换位置
Status changePos(BiTree Root){
    
    
    if (Root == NULL) return OK;
    else {
    
    
        changePos(Root->lchild);
        changePos(Root->rchild);

        /*中间人操作达到值的交换*/
        BiTNode *temp;
        temp = Root->lchild;
        Root->lchild = Root->rchild;
        Root->rchild = temp;
        return OK;
    }
}

int main(){
    
    
    BiTree T=NULL;//（开始定义的是*T）此时T为地址
    printf("\n(Create a Binary Tree )建立一棵二叉树T:\n");
    CreateBiTree(&T);// 建立一棵二叉树
    printf("==============================");
    printf("\nThe PreOrder(先序序列为)is:\n");
    PreOrder(T);
    printf("\n==============================");
    printf("\nThe InOrder(中序序列为)is:\n");
    InOrder(T);
    printf("\n==============================");
    printf("\nThe PostOrder(后序序列为)is:\n");
    PostOrder(T);
    printf("\n==============================");
    printf("\nThe LevelOrder(层次序列为)is:\n");
    LevelOrder(T);
    printf("\n==============================");

    printf("\nThe depth(深度)is: %d\n",depth(T));
    printf("\n==============================\n");

    printf("二叉树节点个数：%d",getNodeNUm(T));

    printf("\n==============================\n");
    printf("二叉树叶子节点个数：%d",getLeafNodeNum(T));

    printf("\n==============================\n");
    if (changePos(T)) {
    
    
        printf("二叉树每个结点的左右子树交换位置成功");
    } else {
    
    
        printf("二叉树每个结点的左右子树交换位置失败");
    };
    printf("\n交换后的(层次序列为)is:\n");
    LevelOrder(T);
    printf("\n==============================\n");
    return 0;
}

效果演示：