前言

树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。

**树**是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。在学习与总结的同时更加深入的了解掌握二叉树。本系列文章将着重介绍一般二叉树、完全二叉树、满二叉树、[线索二叉树](https://www.jianshu.com/p/3965a6e424f5)、[霍夫曼树](https://www.jianshu.com/p/5ad3e97d54a3)、[二叉排序树](https://www.jianshu.com/p/bbe133625c73)、平衡二叉树、红黑树、B树。

1重点名词

1.1 结点

结点是数据结构中的基础，是构成复杂数据结构的基本组成单位。

1.2 数结点

本系列文章中提及的结点专指树的结点。例如：结点A在图中表示为：

#2 数 ###2.1 定义 **树（Tree）**是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中： 1）有且仅有一个特定的称为根（Root）的结点； 2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、......、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。

此外，树的定义还需要强调以下两点： 1）n>0时根结点是唯一的，不可能存在多个根结点，数据结构中的树只能有一个根结点。 2）m>0时，子树的个数没有限制，但它们一定是互不相交的。示例树：下图为一棵普通的树：一般树

2.2树的高度、深度、层、度

深度：对于任意节点n,n的深度为从根到n的唯一路径长，根的深度为0；高度：对于任意节点n,n的高度为从n到一片树叶的最长路径长，所有树叶的高度为0；结点的层次：规定根结点在1层，其它任一结点的层数是其父结点的层数加1 度：结点拥有的子树数目称为结点的度。树的深度：树中所有结点中的最大层次是这棵树的深度下图所示：

$\color{red}{树 }$ 的高度和深度

图片.png 深度定义是从上往下的，高度定义是从下往上的。（其实不用在意这个，反正树的深度高度怎么数都一样的）。深度和高度涉及到结点的层数，有的教材规定根结点在第0层，有的则规定根结点在第1层。原理都是一样的，因教材而异。树从根结点开始往下数，叶子结点所在的最大层数称为树的深度。有的教材对于树的高度定义是高度就是深度（层数是0123，深度=高度=3；层数是1234，深度=高度=4）；而有的教材树的高度则是看一共有几层。也就是说不论根节点在第几层，树的深度都是和最大层的叶子节点一样。而树的高度只要看有几层就行了（0123是四层，1234也是四层）。 ####总之在我看来：

有两种说法： 1.高度就是深度 2.看层数：如果根结点第0，层数=深度=高度-1 如果根结点第1，层数=深度=高度

举个例子：

图	左	右
层数	从第0层开始	从第1层开始
最大层数	3	4
深度	3	4
高度（高度=深度）	3	4
高度（数层数）	4	4

###补充：

根节点在第0层时候，按照北大数据结构视频的说法就是高度数结点数，深度数路径。从A到G，节点是5层，中间有4段路径，所以深度4，高度5。其实也可以理解为数高度时候叶子结点从1开始数。因此空数高度0，只有一个根节点高度1。

但是在清华大学邓俊辉数据结构书中如下：这本书中可以看出数高度时候叶子结点是从0开始的，因此空数高度-1，只有一个根节点高度0。

$\color{red}{结点 }$ 的高度和深度

结点的深度也是从根结点开始数，是第几层也决定于根结点在第0层还是第1层。根结点的高度则取决于它的子树，该节点子树中最远的那个叶子结点作为1开始数。

例如对于BEF三个点：

B的子树是E和F，数B的高度时候，B的子树中离B最远的叶子节点是G，所以G高度为1，B高度3，E高度2。但是F是叶子节点，F没有真子树，F高度就是1。

图	左	右
BFE高度（叶子结点>=0）	3 1 2	3 1 2
BFE高度（叶子结点>0）	2 0 1	2 0 1
BFE深度	0 1 1	1 2 2

2.3 结点关系

结点子树的根结点为该结点的孩子结点。相应该结点称为孩子结点的双亲结点。上图中，A为B的双亲结点，B为A的孩子结点。同一个双亲结点的孩子结点之间互称兄弟结点。上图中，结点B与结点C互为兄弟结点。 #3 二叉数

3.1定义

二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。下图展示了一棵普通二叉树：

###3.2 二叉树特点

由二叉树定义以及图示分析得出二叉树有以下特点： 1）每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。 2）左子树和右子树是有顺序的，次序不能任意颠倒。 3）即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。 4）叶子结点：度为0的结点 ###3.3 二叉树性质

1）在二叉树的第i层上最多有 $2^{i}$ -1 个节点。（i>=1） 2）二叉树中如果深度为k,那么最多有 $2^{k}$ -1个节点。(k>=1） 3）n0=n2+1 n0表示度数为0的节点数，n2表示度数为2的节点数。上图中GFHI是度数为0的结点，ABD是度数为2的节点。 4）在完全二叉树中，具有n个节点的完全二叉树的深度为[log2n]+1，其中[log2n]是向下取整。 5）若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点有如下特性： A.如果i>1，那么序号为i的结点的双亲结点序号为i/2; B.如果i=1，那么序号为i的结点为根节点，无双亲结点; C.如果2i<=n，那么序号为i的结点的左孩子结点序号为2i; D.如果2i>n，那么序号为i的结点无左孩子; E.如果2i+1<=n，那么序号为i的结点右孩子序号为2i+1; F.如果2i+1>n，那么序号为i的结点无右孩子。

3.4 斜树

斜树：所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。

3.5 满二叉树

满二叉树：在一棵二叉树中。如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。满二叉树的特点有： 1）叶子只能出现在最下一层。出现在其它层就不可能达成平衡。 2）非叶子结点的度一定是2。 3）在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多 ###3.6 完全二叉树

完全二叉树：对一颗具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。图展示一棵完全二叉树特点： 1）叶子结点只能出现在最下层和次下层。 2）最下层的叶子结点集中在树的左部。 3）倒数第二层若存在叶子结点，一定在右部连续位置。 4）如果结点度为1，则该结点只有左孩子，即没有右子树。 5）同样结点数目的二叉树，完全二叉树深度最小。注：满二叉树一定是完全二叉树，但反过来不一定成立。 #4 二叉数顺序存储二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引。上图所示的一棵完全二叉树采用顺序存储方式，如下图表示：当二叉树为完全二叉树时，结点数刚好填满数组。那么当二叉树不为完全二叉树时，采用顺序存储形式如何呢？其中，∧表示数组中此位置没有存储结点。此时可以发现，顺序存储结构中已经出现了空间浪费的情况。因此，顺序存储一般适用于完全二叉树。定义结点：

#define MAXSIZE 100 /* 存储空间初始分配量 */
#define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */

typedef int Status;        /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int CElemType;      /* 树结点的数据类型，目前暂定为整型 */
typedef CElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根结点  */
CElemType Nil = 0;   /*设整型以0为空 或者以 INT_MAX(65535)*/

typedef struct {
    int level; //结点层
    int order; //本层的序号(按照满二叉树给定序号规则)
}Position;

####基本操作

#pragma mark -- 二叉树的基本操作
//6.1 visit
Status visit(CElemType c){
    printf("%d ",c);
    return OK;
}

//6.2 构造空二叉树T,因为T是固定数组,不会改变.
Status InitBiTree(SqBiTree T){
    
    for (int i = 0; i < MAX_TREE_SIZE; i++) {
        //将二叉树初始化值置空
        T[i] = Nil;
    }
    
    return OK;
}

//6.3 按层序次序输入二叉树中的结点值(字符型或整型),构造顺序存储的二叉树T
Status CreateBiTree(SqBiTree T){
    int i = 0;
    
    //printf("按层序输入结点的值(整型),0表示空结点, 输入999结束.结点数<=%d\n",MAX_TREE_SIZE);
    /*
     1      -->1
     2     3   -->2
     4  5  6   7 -->3
     8  9 10       -->4
     
     1 2 3 4 5 6 7 8 9 10 Nil Nil Nil
     */
    
    while (i < 10) {
        T[i] = i+1;
        printf("%d ",T[i]);
        
        //结点不为空,且无双亲结点
        if (i != 0 && T[(i+1)/2-1] == Nil && T[i] != Nil) {
            printf("出现无双亲的非根结点%d\n",T[i]);
            exit(ERROR);
        }
        
        i++;
        
    }
    
    //将空赋值给T的后面的结点
    while (i < MAX_TREE_SIZE) {
        T[i] = Nil;
        i++;
    }
    
    return OK;
}

//技巧:
//如果大家想要2个函数的结果一样,但是目的不同;
//在顺序存储结构中, 两个函数完全一样的结果
#define ClearBiTree InitBiTree

/*6.4 判断二叉树是否为空
 初始条件: 二叉树已存在
 操作结果: 若T为空二叉树,则返回TRUE,否则返回FALSE;
 */
Status BiTreeEmpty(SqBiTree T){
    //根结点为空,则二叉树为空
    if (T[0] == Nil)
        return TRUE;
    
    return FALSE;
}

/*6.5 获取二叉树的深度
 初始条件: 二叉树已存在
 操作结果: 返回二叉树T深度;
 */
int BiTreeDepth(SqBiTree T){
    
    int j = -1;
    int i;
    
    //找到最后一个结点
    //MAX_TREE_SIZE -> 100 -> 10 目的找到最后一个结点10的位置
    for (i = MAX_TREE_SIZE-1 ; i>=0; i--) {
        if (T[i] != Nil)
            break;
    }
    
    do {
        j++;
    } while ( powl(2, j) <= i); //计算2的次幂
    
    return j;
}

/*6.6 返回处于位置e(层,本层序号)的结点值
 初始条件: 二叉树T存在,e是T中某个结点(的位置)
 操作结构: 返回处于位置e(层,本层序号)的结点值
 */
CElemType Value(SqBiTree T,Position e){
    
    /*
     Position.level -> 结点层.表示第几层;
     Position.order -> 本层的序号(按照满二叉树给定序号规则)
     */
    
    //pow(2,e.level-1) 找到层序
    printf("%d\n",(int)pow(2,e.level-1));
    
    //e.order
    printf("%d\n",e.order);
    
    //4+2-2;
    return T[(int)pow(2, e.level-1)+e.order-2];
    
}


/*6.7 获取二叉树跟结点的值
 初始条件: 二叉树T存在
 操作结果: 当T不空,用e返回T的根, 返回OK; 否则返回ERROR
 */
Status Root(SqBiTree T,CElemType *e){
    if (BiTreeEmpty(T)) {
        return ERROR;
    }
    
    *e = T[0];
    return OK;
}

/*
 6.8 给处于位置e的结点赋值
 初始条件: 二叉树存在,e是T中某个结点的位置
 操作结果: 给处于位置e的结点赋值Value;
 */
Status Assign(SqBiTree T,Position e,CElemType value){
    
    //找到当前e在数组中的具体位置索引
    int i = (int)powl(2, e.level-1)+e.order -2;
    
    //叶子结点的双亲为空
    if (value != Nil &&  T[(i+1)/2-1] == Nil) {
        return ERROR;
    }
    
    //给双亲赋空值但是有叶子结点
    if (value == Nil && (T[i*2+1] != Nil || T[i*2+2] != Nil)) {
        return  ERROR;
    }
    
    T[i] = value;
    return OK;
}

/*
 6.9 获取e的双亲;
 初始条件: 二叉树存在,e是T中的某一个结点
 操作结果: 若e是T的非根结点, 则返回它的双亲,否则返回"空"
 */
CElemType Parent(SqBiTree T, CElemType e){
    
    //空树
    if (T[0] == Nil) {
        return Nil;
    }
    
    for (int i = 1 ; i < MAX_TREE_SIZE; i++) {
        //找到e
        if (T[i] == e) {
            return T[(i+1)/2 - 1];
        }
    }
    
    //没有找到
    return Nil;
    
}

/*
 6.10 获取某个结点的左孩子;
 初始条件:二叉树T存在,e是某个结点
 操作结果:返回e的左孩子,若e无左孩子,则返回"空"
 */
CElemType LeftChild(SqBiTree T,CElemType e){
    
    //空树
    if (T[0] == Nil) {
        return Nil;
    }
    for (int i = 0 ; i < MAX_TREE_SIZE-1; i++) {
        //找到e
        if (T[i] == e) {
            return T[i*2+1];
        }
    }
    
    //没有找到
    return Nil;
    
}

/*
 6.11 获取某个结点的右孩子;
 初始条件:二叉树T存在,e是某个结点
 操作结果:返回e的左孩子,若e无左孩子,则返回"空"
 */
CElemType RightChild(SqBiTree T,CElemType e){
    
    //空树
    if (T[0] == Nil) {
        return Nil;
    }
    for (int i = 0 ; i < MAX_TREE_SIZE-1; i++) {
        //找到e
        if (T[i] == e) {
            return T[i*2+2];
        }
    }
    
    //没有找到
    return Nil;
    
}

/*
 6.12 获取结点的左兄弟
 初始条件:  二叉树T存在,e是T中某个结点
 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂
 */
CElemType LeftSibling(SqBiTree T,CElemType e)
{
    /* 空树 */
    if(T[0]==Nil)
        return Nil;
    
    for(int i=1;i<=MAX_TREE_SIZE-1;i++)
    /* 找到e且其序号为偶数(是右孩子) */
        if(T[i]==e&&i%2==0)
            return T[i-1];
    
    return Nil; /* 没找到e */
}

/* 6.13 获取结点的右兄弟
 初始条件: 二叉树T存在,e是T中某个结点
 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂
 */
CElemType RightSibling(SqBiTree T,CElemType e)
{
    /* 空树 */
    if(T[0]==Nil)
        return Nil;
    
    for(int i=1;i<=MAX_TREE_SIZE-1;i++)
    /* 找到e且其序号为奇数(是左孩子) */
        if(T[i]==e&&i%2==1)
            return T[i+1];
    
    return Nil; /* 没找到e */
}

####前序遍历前序遍历通俗的说就是从二叉树的根结点出发，当第一次到达结点时就输出结点数据，按照先向左在向右的方向访问。上图所示二叉树访问如下：

从根结点出发，则第一次到达结点A，故输出A;
继续向左访问，第一次访问结点B，故输出B；
按照同样规则，输出D，输出H；
当到达叶子结点H，返回到D，此时已经是第二次到达D，故不在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；
I为叶子结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故输出E；
向E左子树，故输出J；
按照同样的访问规则，继续输出C、F、G；

输出结果： ABDHIEJCFG

void PreTraverse(SqBiTree T,int e){
    
    //打印结点数据
    visit(T[e]);
    
    //先序遍历左子树
    if (T[2 * e + 1] != Nil) {
        PreTraverse(T, 2*e+1);
    }
    //最后先序遍历右子树
    if (T[2 * e + 2] != Nil) {
        PreTraverse(T, 2*e+2);
    }
}
Status PreOrderTraverse(SqBiTree T){
    
    //树不为空
    if (!BiTreeEmpty(T)) {
        PreTraverse(T, 0);
    }
    printf("\n");
    return  OK;
}

####中序遍历中序遍历就是从二叉树的根结点出发，当第二次到达结点时就输出结点数据，按照先向左在向右的方向访问。上图所示二叉树中序访问如下：

从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；
到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；
H右子树为空，则返回至D，此时第二次到达D，故输出D；
由D返回至B，第二次到达B，故输出B；
按照同样规则继续访问，输出J、E、A、F、C、G；

则3.13所示二叉树的中序遍历输出为： HDIBJEAFCG

void InTraverse(SqBiTree T, int e){
    
    /* 左子树不空 */
    if (T[2*e+1] != Nil)
        InTraverse(T, 2*e+1);
    
    visit(T[e]);
    
    /* 右子树不空 */
    if (T[2*e+2] != Nil)
        InTraverse(T, 2*e+2);
}

Status InOrderTraverse(SqBiTree T){
    
    /* 树不空 */
    if (!BiTreeEmpty(T)) {
        InTraverse(T, 0);
    }
    printf("\n");
    return OK;
}

####后序遍历后序遍历就是从二叉树的根结点出发，当第三次到达结点时就输出结点数据，按照先向左在向右的方向访问。

图所示二叉树后序访问如下：

从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；
到达H，H左子树为空，则返回到H，此时第二次访问H，不输出H；
H右子树为空，则返回至H，此时第三次到达H，故输出H；
由H返回至D，第二次到达D，不输出D；
继续访问至I，I左右子树均为空，故第三次访问I时，输出I；
返回至D，此时第三次到达D，故输出D；
按照同样规则继续访问，输出J、E、B、F、G、C，A；

则图3.13所示二叉树的后序遍历输出为： HIDJEBFGCA

void PostTraverse(SqBiTree T,int e)
{   /* 左子树不空 */
    if(T[2*e+1]!=Nil)
        PostTraverse(T,2*e+1);
    /* 右子树不空 */
    if(T[2*e+2]!=Nil)
        PostTraverse(T,2*e+2);
    
    visit(T[e]);
}
Status PostOrderTraverse(SqBiTree T)
{
    if(!BiTreeEmpty(T)) /* 树不空 */
        PostTraverse(T,0);
    printf("\n");
    return OK;
}

####层序遍历层次遍历就是按照树的层次自上而下的遍历二叉树。针对图3.13所示二叉树的层次遍历结果为： ABCDEFGHIJ

/*
 6.14 层序遍历二叉树
 */
void LevelOrderTraverse(SqBiTree T){
    
    int i = MAX_TREE_SIZE-1;
    
    //找到最后一个非空结点的序号
    while (T[i] == Nil) i--;
    
    //从根结点起,按层序遍历二叉树
    for (int j = 0; j <= i; j++)
        //只遍历非空结点
        if (T[j] != Nil)
            visit(T[j]);
    
    printf("\n");
}

测试

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("二叉树顺序存储结构实现!\n");
    
    Status iStatus;
    Position p;
    CElemType e;
    SqBiTree T;
    
    InitBiTree(T);
    CreateBiTree(T);
    printf("建立二叉树后,树空否？%d(1:是 0:否) \n",BiTreeEmpty(T));
    printf("树的深度=%d\n",BiTreeDepth(T));
    
    p.level=3;
    p.order=2;
    e=Value(T,p);
    printf("第%d层第%d个结点的值: %d\n",p.level,p.order,e);
    
    
    iStatus = Root(T, &e);
    if (iStatus) {
        printf("二叉树的根为:%d\n",e);
    }else
    {
        printf("树为空,无根!\n");
    }
    
    //向树中3层第2个结点位置上结点赋值99
    e = 99;
    Assign(T, p, e);
    
    //获取树中3层第2个结点位置结点的值是多少:
    e=Value(T,p);
    printf("第%d层第%d个结点的值: %d\n",p.level,p.order,e);
    
    //找到e这个结点的双亲;
    printf("结点%d的双亲为%d_",e,Parent(T, e));
    //找到e这个结点的左右孩子;
    printf("左右孩子分别为:%d,%d\n",LeftChild(T, e),RightChild(T, e));
    //找到e这个结点的左右兄弟;
    printf("结点%d的左右兄弟:%d,%d\n",e,LeftSibling(T, e),RightSibling(T, e));
    
    
    Assign(T, p, 5);
    
    printf("二叉树T层序遍历:");
    LevelOrderTraverse(T);
    
    printf("二叉树T先序遍历:");
    PreOrderTraverse(T);
    
    printf("二叉树T中序遍历:");
    InOrderTraverse(T);
    
    printf("二叉树T后序遍历:");
    PostOrderTraverse(T);
    
    return 0;
}

#5 二叉数链式存储既然顺序存储不能满足二叉树的存储需求，那么考虑采用链式存储。由二叉树定义可知，二叉树的每个结点最多有两个孩子。因此，可以将结点数据结构定义为一个数据和两个指针域。表示方式如下图所示： ####定义结点代码：

typedef char CElemType;
CElemType Nil=' '; /* 字符型以空格符为空 */
typedef struct BiTNode  /* 结点结构 */
{
    CElemType data;        /* 结点数据 */
    struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;

####二叉树赋值

int indexs = 1;
typedef char String[24]; /*  0号单元存放串的长度 */
String str;
Status StrAssign(String T,char *chars)
{
    int i;
    if(strlen(chars)>MAXSIZE)
        return ERROR;
    else
    {
        T[0]=strlen(chars);
        for(i=1;i<=T[0];i++)
            T[i]=*(chars+i-1);
        return OK;
    }
}

所示的二叉树可以采用图表示。 ####基本操作

typedef char CElemType;
CElemType Nil=' '; /* 字符型以空格符为空 */
typedef struct BiTNode  /* 结点结构 */
{
    CElemType data;        /* 结点数据 */
    struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;

/*7.1 打印数据*/
Status visit(CElemType e)
{
    printf("%c ",e);
    return OK;
}

/* 7.2 构造空二叉树T */
Status InitBiTree(BiTree *T)
{
    *T=NULL;
    return OK;
}

/* 7.3 销毁二叉树
 初始条件: 二叉树T存在。
 操作结果: 销毁二叉树T
 */
void DestroyBiTree(BiTree *T)
{
    if(*T)
    {
        /* 有左孩子 */
        if((*T)->lchild)
            DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
        
        /* 有右孩子 */
        if((*T)->rchild)
            DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
        
        free(*T); /* 释放根结点 */
        
        *T=NULL; /* 空指针赋0 */
    }
}
#define ClearBiTree DestroyBiTree

/*7.4 创建二叉树
 按前序输入二叉树中的结点值(字符),#表示空树;
 */
void CreateBiTree(BiTree *T){
    
    CElemType ch;
    
    //获取字符
    ch = str[indexs++];
    
    //判断当前字符是否为'#'
    if (ch == '#') {
        *T = NULL;
    }else
    {
        //创建新的结点
        *T = (BiTree)malloc(sizeof(BiTNode));
        //是否创建成功
        if (!*T) {
            exit(OVERFLOW);
        }
        
        /* 生成根结点 */
        (*T)->data = ch;
        /* 构造左子树 */
        CreateBiTree(&(*T)->lchild);
        /* 构造右子树 */
        CreateBiTree(&(*T)->rchild);
    }
    
}


/*
 7.5 二叉树T是否为空;
 初始条件: 二叉树T存在
 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE
 */
Status BiTreeEmpty(BiTree T)
{
    if(T)
        return FALSE;
    else
        return TRUE;
}

/*
 7.6 二叉树T的深度
 初始条件: 二叉树T存在
 操作结果: 返回T的深度
 */
int BiTreeDepth(BiTree T){
    
    int i,j;
    if(!T)
        return 0;
    
    //计算左孩子的深度
    if(T->lchild)
        i=BiTreeDepth(T->lchild);
    else
        i=0;
    
    //计算右孩子的深度
    if(T->rchild)
        j=BiTreeDepth(T->rchild);
    else
        j=0;
    
    //比较i和j
    return i>j?i+1:j+1;
}

/*
 7.7 二叉树T的根
 初始条件: 二叉树T存在
 操作结果: 返回T的根
 */
CElemType Root(BiTree T){
    if (BiTreeEmpty(T))
        return Nil;
    
    return T->data;
}

/*
 7.8 返回p所指向的结点值;
 初始条件: 二叉树T存在，p指向T中某个结点
 操作结果: 返回p所指结点的值
 */
CElemType Value(BiTree p){
    return p->data;
}

/*
 7.8 给p所指结点赋值为value;
 初始条件: 二叉树T存在，p指向T中某个结点
 操作结果: 给p所指结点赋值为value
 */
void Assign(BiTree p,CElemType value)
{
    p->data=value;
}

####前序递归遍历 规则: 若⼆叉树为空,则空操作返回; 否则先访问根结点,然后前序遍历左⼦树,在前序遍历右⼦树

/*
 7.8  前序递归遍历T
 初始条件:二叉树T存在;
 操作结果: 前序递归遍历T
 */

void PreOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;
    printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
    PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
    PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}

####中序递归遍历 规则: 若⼆叉树为空,则空操作返回; 否则先访问根结点,然后前序遍历左⼦树,在前序遍历右⼦树

/*
 7.9  中序递归遍历T
 初始条件:二叉树T存在;
 操作结果: 中序递归遍历T
 */
void InOrderTraverse(BiTree T)
{
    if(T==NULL)
        return ;
    InOrderTraverse(T->lchild); /* 中序遍历左子树 */
    printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
    InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}

####后序递归遍历 规则: 若⼆叉树为空,则空操作返回; 否则从根结点开始(注意并不是先访问根结点), 中序遍历根结点的左⼦树,然后是访问根结点,最后中序遍历右⼦树

/*
 7.10  后序递归遍历T
 初始条件:二叉树T存在;
 操作结果: 中序递归遍历T
 */
void PostOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild); /* 先后序遍历左子树  */
    PostOrderTraverse(T->rchild); /* 再后序遍历右子树  */
    printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}

####测试

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("二叉树链式存储结构实现!\n");
    
    int i;
    BiTree T;
    CElemType e1;
    
    InitBiTree(&T);
    
    StrAssign(str,"ABDH#K###E##CFI###G#J##");
    
    CreateBiTree(&T);
    printf("二叉树是否为空%d(1:是 0:否),树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    
    e1=Root(T);
    printf("二叉树的根为: %c\n",e1);
    
    printf("\n前序遍历二叉树:");
    PreOrderTraverse(T);
    
    printf("\n中序遍历二叉树:");
    InOrderTraverse(T);
    
    printf("\n后序遍历二叉树:");
    PostOrderTraverse(T);
    
    printf("\n");
    
    return 0;
}

6 遍历常考考点

对于二叉树的遍历有一类典型题型。 1）已知前序遍历序列和中序遍历序列，确定一棵二叉树。例题：若一棵二叉树的前序遍历为ABCDEF，中序遍历为CBAEDF，请画出这棵二叉树。分析：前序遍历第一个输出结点为根结点，故A为根结点。早中序遍历中根结点处于左右子树结点中间，故结点A的左子树中结点有CB，右子树中结点有EDF。如图所示按照同样的分析方法，对A的左右子树进行划分，最后得出二叉树的形态如图所示： 2）已知后序遍历序列和中序遍历序列，确定一棵二叉树。后序遍历中最后访问的为根结点，因此可以按照上述同样的方法，找到根结点后分成两棵子树，进而继续找到子树的根结点，一步步确定二叉树的形态。注：已知前序遍历序列和后序遍历序列，不可以唯一确定一棵二叉树。

demo

•

数据结构与算法[二叉树基础]

前言