【数据结构】【王道】【树与二叉树】二叉树的实现及基本操作（可直接运行）

总目录

各部分的解释已经以注释形式写于代码中。

1.基本操作

1.1 结构体构造

typedef struct BiTNode {
    // 数据域
    char data;
    // 左、右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

1.2 初始化

// 初始化
void InitTree(BiTree &T) {
    // 初始化可将根节点置空，空树
    T = NULL;
    // 插入根节点
    // 分配空间
    T = (BiTree)malloc(sizeof(BiTree));
    // 赋值
    T->data = 'A';
    // 初始无左右子树
    T->lchild = NULL;
    T->rchild = NULL;
}

1.3 左插入结点

// 左插入结点
bool InsertLeftTreeNode(BiTNode* &T, char x) {
    // 分配空间
    BiTNode *p = (BiTNode*)malloc(sizeof(BiTNode));
    // 分配空间失败的情况
    if(p == NULL) {
        return false;
    }
    // 数据域赋值
    p->data = x;
    // 初始插入，无左右孩子，置空
    p->lchild = NULL;
    p->rchild = NULL;
    // 作为指定插入结点的左孩子
    T->lchild = p;
    return true;
}

1.4 右插入节点

// 右插入结点
bool InsertRightTreeNode(BiTNode* &T, char x) {
    // 分配空间
    BiTNode *p = (BiTNode*)malloc(sizeof(BiTNode));
    // 分配空间失败的情况
    if(p == NULL) {
        return false;
    }
    // 数据域赋值
    p->data = x;
    // 初始插入，无左右孩子，置空
    p->lchild = NULL;
    p->rchild = NULL;
    // 作为指定插入结点的左孩子
    T->rchild = p;
    return true;
}

1.5 访问结点

// 访问结点
void visit(BiTree T) {
    printf("%c   ", T->data);
}

1.6 先序遍历（递归）

// 先序遍历
// 即根左右，先访问根结点，再依次访问左右结点
void PreOrder(BiTree T) {
    // 根节点为空则直接跳过
    if(T != NULL) {
        // 访问根结点
        visit(T);
        // 递归访问左子树
        PreOrder(T->lchild);
        // 地柜访问右子树
        PreOrder(T->rchild);
    }
}

1.7 中序遍历（递归）

// 中序遍历
// 即左根右，先访问左结点，再访问根结点，最后访问右结点
void InOrder(BiTree T) {
    if(T != NULL) {
        // 递归遍历左子树
        InOrder(T->lchild);
        // 访问根结点
        visit(T);
        // 递归遍历右子树
        InOrder(T->rchild);
    }
}

1.8 后序遍历（递归）

// 后序遍历
// 即左右根，先依次访问左右结点，最后访问根结点
void PostOrder(BiTree T) {
    if(T != NULL) {
        // 递归遍历左子树
        PostOrder(T->lchild);
        // 递归遍历右子树
        PostOrder(T->rchild);
        // 访问根结点
        visit(T);
    }
}

1.9 树的深度

// 树的深度
int treeDepth(BiTree T) {
    // 根结点为空，则深度为0
    if(T == NULL) {
        return 0;
    } else {
        // 递归遍历左子树，获得左子树深度
        int l = treeDepth(T->lchild);
        // 递归遍历右子树，获得右子树深度
        int r = treeDepth(T->rchild);
        // 树的深度=Max{左子树深度，右子树深度} + 1
        // 加1相当于访问根节点，包括根结点深度+1
        return l > r ? l + 1 : r + 1;
    }
}

2.完整代码

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

typedef struct BiTNode {
    // 数据域
    char data;
    // 左、右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

// 初始化
void InitTree(BiTree &T) {
    // 初始化可将根节点置空，空树
    T = NULL;
    // 插入根节点
    // 分配空间
    T = (BiTree)malloc(sizeof(BiTree));
    // 赋值
    T->data = 'A';
    // 初始无左右子树
    T->lchild = NULL;
    T->rchild = NULL;
}

// 左插入结点
bool InsertLeftTreeNode(BiTNode* &T, char x) {
    // 分配空间
    BiTNode *p = (BiTNode*)malloc(sizeof(BiTNode));
    // 分配空间失败的情况
    if(p == NULL) {
        return false;
    }
    // 数据域赋值
    p->data = x;
    // 初始插入，无左右孩子，置空
    p->lchild = NULL;
    p->rchild = NULL;
    // 作为指定插入结点的左孩子
    T->lchild = p;
    return true;
}

// 右插入结点
bool InsertRightTreeNode(BiTNode* &T, char x) {
    // 分配空间
    BiTNode *p = (BiTNode*)malloc(sizeof(BiTNode));
    // 分配空间失败的情况
    if(p == NULL) {
        return false;
    }
    // 数据域赋值
    p->data = x;
    // 初始插入，无左右孩子，置空
    p->lchild = NULL;
    p->rchild = NULL;
    // 作为指定插入结点的左孩子
    T->rchild = p;
    return true;
}

// 访问结点
void visit(BiTree T) {
    printf("%c   ", T->data);
}

// 先序遍历
// 即根左右，先访问根结点，再依次访问左右结点
void PreOrder(BiTree T) {
    // 根节点为空则直接跳过
    if(T != NULL) {
        // 访问根结点
        visit(T);
        // 递归访问左子树
        PreOrder(T->lchild);
        // 地柜访问右子树
        PreOrder(T->rchild);
    }
}

// 中序遍历
// 即左根右，先访问左结点，再访问根结点，最后访问右结点
void InOrder(BiTree T) {
    if(T != NULL) {
        // 递归遍历左子树
        InOrder(T->lchild);
        // 访问根结点
        visit(T);
        // 递归遍历右子树
        InOrder(T->rchild);
    }
}

// 后序遍历
// 即左右根，先依次访问左右结点，最后访问根结点
void PostOrder(BiTree T) {
    if(T != NULL) {
        // 递归遍历左子树
        PostOrder(T->lchild);
        // 递归遍历右子树
        PostOrder(T->rchild);
        // 访问根结点
        visit(T);
    }
}

// 树的深度
int treeDepth(BiTree T) {
    // 根结点为空，则深度为0
    if(T == NULL) {
        return 0;
    } else {
        // 递归遍历左子树，获得左子树深度
        int l = treeDepth(T->lchild);
        // 递归遍历右子树，获得右子树深度
        int r = treeDepth(T->rchild);
        // 树的深度=Max{左子树深度，右子树深度} + 1
        // 加1相当于访问根节点，包括根结点深度+1
        return l > r ? l + 1 : r + 1;
    }
}


int main() {
    BiTree T;
    InitTree(T);
    InsertLeftTreeNode(T, 'B');
    InsertRightTreeNode(T, 'C');
    InsertLeftTreeNode(T->lchild, 'D');
    InsertRightTreeNode(T->lchild, 'E');
    InsertLeftTreeNode(T->rchild, 'F');
    InsertRightTreeNode(T->rchild, 'G');
    printf("PreOrder\n");
    PreOrder(T);
    printf("\nInOrder\n");
    InOrder(T);
    printf("\nPostOrder\n");
    PostOrder(T);
    printf("\ntreeDepth:%d\n", treeDepth(T));
}

3.运行结果