【C语言 数据结构】树和二叉树

树的定义和基本术语

树结构通常用来存储逻辑关系为 “一对多” 的数据。例如：

这些元素具有的就是 “一对多” 的逻辑关系，例如元素 A 同时和 B、C、D 有关系，元素 D 同时和 A、H、I、J 有关系等。 观察这些元素之间的逻辑关系会发现，它们整体上很像一棵倒着的树，这也是将存储它们的结构起名为“树”（或者 “树形”）的原因。

存储具有 “一对多” 逻辑关系的数据，数据结构推荐使用树存储结构。

---

有关树的术语

• 结点：和链表类似，树存储结构中也将存储的各个元素称为 “结点”。在上图中，元素 A 就是一个结点。对于树中某些特殊位置的结点，还可以进行更细致的划分，比如：

  • 父结点（双亲结点）、孩子结点和兄弟结点：A 是 B、C、D 结点的父结点（也称为“双亲结点”），而 B、C、D 都是 A 结点的孩子结点（也称“子结点”）。对于 B、C、D 来说，它们都有相同的父结点，所以它们互为兄弟结点；
  • 树根结点（简称 “根结点” ）：特指树中没有双亲（父亲）的结点，一棵树有且仅有一个根结点。结点 A 就是整棵树的根结点；
  • 叶子结点（简称 “叶结点” ）：特指树中没有孩子的结点，一棵树可以有多个叶子结点，结点 K、L、F、G、M、I、J 都是叶子结点。

• 子树：A 是整棵树的根结点。但如果单看结点 B、E、F、K、L 组成的部分来说，它们也组成了一棵树，结点 B 是这棵树的根结点。通常，我们将一棵树中几个结点构成的“小树”称为这棵树的“子树”。

  • 知道了子树的概念后，树也可以这样定义：树是由根结点和若干棵子树构成的。上图这棵树就是由结点 A 和分别以 B、C、D 为根节点的子树构成。
  • 注意：单个结点也可以看作是一棵树，该结点即为根结点。结点 K、L、F 各自就可以看作是一棵树，只不过树中只有一个根节点而已。

• 结点的度：一个结点拥有子树的个数，就称为该结点的度（Degree）。根结点 A 有 3 个子树，它们的根节点分别是 B、C、D，因此结点 A 的度为 3。

  • 比较一棵树中所有结点的度，最大的度即为整棵树的度。上图中，所有结点中最大的度为 3，所以整棵树的度就是 3。

• 结点的层次：从一棵树的树根开始，树根所在层为第一层，根的孩子结点所在的层为第二层，依次类推。

  • A 结点在第一层，B、C、D 为第二层，E、F、G、H、I、J 在第三层，K、L、M 在第四层。

  • 树中结点层次的最大值，称为这棵树的深度或者高度。上图这棵树的深度为 4。

  • 如果两个结点的父结点不同，但它们父结点的层次相同，那么这两个结点互为堂兄弟。例如结点 G 和 E、F、H、I、J 的父结点都在第二层，所以它们互为堂兄弟。

• 有序树和无序树：如果一棵树中，各个结点左子树和右子树的位置不能交换，那么这棵树就称为有序树。反之，如果树中结点的左、右子树可以互换，那么这棵树就是一棵无序树。

  • 在有序树中，结点最左边的子树称为 “第一个孩子”，最右边的称为 “最后一个孩子”。上图这棵树来说，如果它是一棵有序树，那么以结点 B 为根结点的子树为整棵树的第一个孩子，以结点 D 为根结点的子树为整棵树的最后一个孩子。

• 森林：由 m（m >= 0）个互不相交的树组成的集合就称为森林。比如上图中除去 A 结点，那么分别以 B、C、D 为根结点的三棵子树就可以称为森林。

  • 前面讲到，树可以理解为是由根结点和若干子树构成的，而这若干子树本身就是一个森林，因此树还可以理解为是由根结点和森林组成的

---

树的其它表示方法

---

二叉树

二叉树的性质

简单地理解，满足以下两个条件的树就是二叉树：

• 本身是有序树；

• 树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2；

---

经过前人的总结，二叉树具有以下几个性质：

• 二叉树中，第 i 层最多有 2i-1 个结点。

• 如果二叉树的深度为 K，那么此二叉树最多有 2K-1 个结点。

• 二叉树中，终端结点数（叶子结点数）为 n0，度为 2 的结点数为 n2，则 n0=n2+1。

性质 3 的计算方法为：对于一个二叉树来说，除了度为 0 的叶子结点和度为 2 的结点，剩下的就是度为 1 的结点（设为 n1），那么总结点 n=n0+n1+n2。
同时，对于每一个结点来说都是由其父结点分支表示的，假设树中分枝数为 B，那么总结点数 n=B+1。而分枝数是可以通过 n1 和 n2 表示的，即 B=n1+2n2。所以，n 用另外一种方式表示为 n=n1+2n2+1。
两种方式得到的 n 值组成一个方程组，就可以得出 n0=n2+1。

---

满二叉树：如果二叉树中除了叶子结点，每个结点的度都为 2，则此二叉树称为满二叉树。

满二叉树除了满足普通二叉树的性质，还具有以下性质：

• 满二叉树中第 i 层的节点数为 2i-1 个。
• 深度为 k 的满二叉树必有 2k-1 个节点 ，叶子数为 2k-1。
• 满二叉树中不存在度为 1 的节点，每一个分支点中都两棵深度相同的子树，且叶子节点都在最底层。
• 具有 n 个节点的满二叉树的深度为 log2(n+1)。

---

完全二叉树：如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。

完全二叉树除了具有普通二叉树的性质，它自身也具有一些独特的性质，比如说，n 个结点的完全二叉树的深度为 ⌊log2n⌋+1。
⌊log2n⌋ 表示取小于 log2n 的最大整数。例如，⌊log24⌋ = 2，而 ⌊log25⌋ 结果也是 2。

对于任意一个结点 i ，完全二叉树还有以下几个结论成立：

• 当 i>1 时，父亲结点为结点 [i/2] 。（i=1 时，表示的是根结点，无父亲结点）
• 如果 2*i>n（总结点的个数） ，则结点 i 肯定没有左孩子（为叶子结点）；否则其左孩子是结点 2*i 。
• 如果 2i+1>n ，则结点 i 肯定没有右孩子；否则右孩子是结点 2i+1 。

---

二叉树的存储结构

顺序存储

一棵普通二叉树转化为完全二叉树的方法很简单，只需要给二叉树额外添加一些结点，就可以把它"拼凑"成完全二叉树。

左侧是普通二叉树，右侧是转化后的完全（满）二叉树。解决了二叉树的转化问题，接下来学习如何顺序存储完全（满）二叉树。所谓顺序存储完全二叉树，就是从树的根结点开始，按照层次将树中的结点逐个存储到数组中。

各个结点在顺序表中的存储状态如图

存储由普通二叉树转化来的完全二叉树也是如此

实现代码如下所示

#include 
#define NODENUM 7
#define ElemType int
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[NODENUM];
//存储二叉树
void InitBiTree(BiTree T) {
    ElemType node;
    int i = 0;
    printf("按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:");
    while (scanf("%d", &node))
    {
        T[i] = node;
        i++;
    }
}
//查找某个结点的双亲结点的值
ElemType Parent(BiTree T, ElemType e) {
    int i;
    if (T[0] == 0) {
        printf("存储的是一棵空树\n");
    }
    else
    {
        if (T[0] == e) {
            printf("当前结点是根节点，没有双亲结点\n");
            return 0;
        }
        for (i = 1; i < NODENUM; i++) {
            if (T[i] == e) {
                //借助各个结点的标号(数组下标+1)，找到双亲结点的存储位置
                return T[(i + 1) / 2 - 1];
            }
        }
        printf("二叉树中没有指定结点\n");
    }
    return -1;
}
//查找某个结点的左孩子结点的值
ElemType LeftChild(BiTree T, ElemType e) {
    int i;
    if (T[0] == 0) {
        printf("存储的是一棵空树\n");
    }
    else
    {
        for (i = 1; i < NODENUM; i++) {
            if (T[i] == e) {
                //借助各个结点的标号(数组下标+1)，找到左孩子结点的存储位置
                if (((i + 1) * 2 < NODENUM) && (T[(i + 1) * 2 - 1] != 0)) {
                    return T[(i + 1) * 2 - 1];
                }
                else
                {
                    printf("当前结点没有左孩子\n");
                    return 0;
                }
            }
        }
        printf("二叉树中没有指定结点\n");
    }
    return -1;
}
//查找某个结点的右孩子结点的值
ElemType RightChild(BiTree T, ElemType e) {
    int i;
    if (T[0] == 0) {
        printf("存储的是一棵空树\n");
    }
    else
    {
        for (i = 1; i < NODENUM; i++) {
            if (T[i] == e) {
                //借助各个结点的标号(数组下标+1)，找到左孩子结点的存储位置
                if (((i + 1) * 2 + 1 < NODENUM) && (T[(i + 1) * 2] != 0)) {
                    return T[(i + 1) * 2];
                }
                else
                {
                    printf("当前结点没有右孩子\n");
                    return 0;
                }
            }
        }
        printf("二叉树中没有指定结点\n");
    }
    return -1;
}
int main() {
    int res;
    BiTree T = { 0 };
    InitBiTree(T);
    res = Parent(T, 3);
    if (res != 0 && res != -1) {
        printf("结点3的双亲结点的值为 %d\n", res);
    }
    res = LeftChild(T, 2);
    if (res != 0 && res != -1) {
        printf("结点2的左孩子的值为 %d\n", res);
    }
    res = RightChild(T, 2);
    if (res != 0 && res != -1) {
        printf("结点2的右孩子的值为 %d\n", res);
    }
    return 0;
}

---

链式存储

所谓二叉树的链式存储，其实就是用链表存储二叉树，具体的存储方案是：从树的根节点开始，将各个节点及其左右孩子使用链表存储。例如图 1 是一棵普通的二叉树，如果选择用链表存储，各个结点的存储状态如下图所示：

由图 2 可知，采用链式存储二叉树时，树中的结点由 3 部分构成（如图 3 所示）：

• 指向左孩子节点的指针（Lchild）；
• 节点存储的数据（data）；
• 指向右孩子节点的指针（Rchild）；

代码实现

#include 
#include 
#define TElemType int
typedef struct BiTNode {
    TElemType data;//数据域
    struct BiTNode* lchild, * rchild;//左右孩子指针
}BiTNode, * BiTree;
void CreateBiTree(BiTree* T) {
    *T = (BiTNode*)malloc(sizeof(BiTNode));
    (*T)->data = 1;
    (*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->data = 2;
    (*T)->rchild = (BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->data = 3;
    (*T)->rchild->lchild = NULL;
    (*T)->rchild->rchild = NULL;
    (*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->lchild->data = 4;
    (*T)->lchild->rchild = NULL;
    (*T)->lchild->lchild->lchild = NULL;
    (*T)->lchild->lchild->rchild = NULL;
}
//后序遍历二叉树，释放树占用的内存
void DestroyBiTree(BiTree T) {
    if (T) {
        DestroyBiTree(T->lchild);//销毁左孩子
        DestroyBiTree(T->rchild);//销毁右孩子
        free(T);//释放结点占用的内存
    }
}
int main() {
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("根节点的左孩子结点为：%d\n", Tree->lchild->data);
    printf("根节点的右孩子结点为：%d\n", Tree->rchild->data);
    DestroyBiTree(Tree);
    return 0;
}

---