【嵌入式 C 常用算法 3 -- 非线性存储结构 二叉树】

树概念介绍

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

图 1-1

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

树相关术语

结点

和链表类似，树存储结构中也将存储的各个元素称为 “结点”。例如在图 1-1 中，元素 A 就是一个结点。

对于树中某些特殊位置的结点，还可以进行更细致的划分，比如：
父结点（双亲结点）、孩子结点和兄弟结点：以图 1-1 中的结点 A、B、C、D 为例，A 是 B、C、D 结点的父结点（也称为“双亲结点”），而 B、C、D 都是 A 结点的孩子结点（也称“子结点”）。对于 B、C、D 来说，它们都有相同的父结点，所以它们互为兄弟结点；
树根结点（简称 “根结点” ）：特指树中没有双亲（父亲）的结点，一棵树有且仅有一个根结点。例如图 1a) 中，结点 A 就是整棵树的根结点；

叶子结点（简称 “叶结点” ）：特指树中没有孩子的结点，一棵树可以有多个叶子结点。例如图 1a) 中，结点 K、L、F、G、M、I、J 都是叶子结点。

子树

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

结点的度

一个结点拥有子树的个数，就称为该结点的度（Degree）。例如图 1a) 中，根结点 A 有 3 个子树，它们的根节点分别是 B、C、D，因此结点 A 的度为 3。
比较一棵树中所有结点的度，最大的度即为整棵树的度。比如图 1-1 中，所有结点中最大的度为 3，所以整棵树的度就是 3。

结点的层次

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

对于图 1-1 这棵树来说，A 结点在第一层，B、C、D 为第二层，E、F、G、H、I、J 在第三层，K、L、M 在第四层。

树中结点层次的最大值，称为这棵树的深度或者高度。例如图 1-1 这棵树的深度为 4。
如果两个结点的父结点不同，但它们父结点的层次相同，那么这两个结点互为堂兄弟。例如图 1-1 中，结点 G 和 E、F、H、I、J 的父结点都在第二层，所以它们互为堂兄弟。

有序树和无序树

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

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

森林

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

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

空树（简单了解即可）

空树指的是没有任何结点的树，连根结点都没有。

二叉树

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

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

例如，图 1-2 a) 就是一棵二叉树，而图 1-2 b) 则不是。

图 1-2

二叉树性质

二叉树的常用性质：

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

至于其他性质这里就不做介绍了。

满二叉树

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

图 1-3 满二叉树示意图

完全二叉树

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

图 1-4 完全二叉树示意图

二叉树的深度遍历

二叉树深度遍历本质上就是深度优先遍历
前序遍历就是优先访问根节点，中序遍历是第二个访问根节点，后续遍历就是访问完左右节点之后，最后访问根节点。

前序遍历

遍历顺序:根节点->左节点->右节点
遍历结果:4->2->1->3->6->5->7

可能有些小伙伴会有疑惑为什么在前序遍历结果是4->2->1，而不是4-2-6。你不是说前序遍历的顺序不是根节点->左节点->右节点。2遍历了，应该遍历6啊。

如果你有这样的疑问，那是因为你混淆了深度优先和广度优先的概念了。4-2-6是遍历了第一层4，然后接着遍历了4的下一层2，6。这明显是一个广度优先的遍历结果。那什么是深度优先呢？用幼儿园的话来说，你要向前走而不是向左右走。和深度遍历相结合的数据结构是栈，这是一个具有后入先出特性的数据结构，当你从4遍历到左节点2之后，4和2都已经入栈了，而2是栈顶的元素，根据栈后入先出的原理，计算机会先处理2这个节点而不是4，所以2成为了新的根节点。那么我们输出4-2之后谁是2的左节点，明显是1，而不会是6啊。所以是这里是一个4-2-1的顺序。

中序遍历

遍历顺序:左节点->根节点->右节点
遍历结果:1->2->3->4->5->6->7

后续遍历

遍历顺序:左节点->右节点->根节点
遍历结果：1->3->2->5->7->6->4

二叉树的层次遍历

二叉树的层次遍历的本质是广度优先遍历

二叉树的顺序存储结构

二叉树的顺序存储，指的是使用顺序表（数组）存储二叉树。对的，你没有看错，虽然树是非线性存储结构，但也可以用顺序表存储。

需要注意的是，顺序存储只适用于完全二叉树。对于普通的二叉树，必须先将其转化为完全二叉树，才能存储到顺序表中。

满二叉树也是完全二叉树，可以直接用顺序表存储。

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

图 2-1 普通二叉树的转化

图 2-1 左侧是普通二叉树，右侧是转化后的完全（满）二叉树。解决了二叉树的转化问题，接下来学习如何顺序存储完全（满）二叉树。

所谓顺序存储完全二叉树，就是从树的根结点开始，按照层次将树中的结点逐个存储到数组中。

图 2-2 完全二叉树示意图普通二叉树的转化

例如存储图 2-2 中的完全二叉树，各个结点在顺序表中的存储状态如图 2-3 所示：

图 2-3 完全二叉树存储状态示意图

存储由普通二叉树转化来的完全二叉树也是如此，比如将图 2-1 中的普通二叉树存储到顺序表中，树中结点的存储状态如图 2-4 所示：

图 2-4 普通二叉树的存储状态

由此就实现了完全二叉树的顺序存储。

二叉树的顺序存储结构C代码实现

#define NODENUM 7  //二叉树中的结点数量
#define ElemType int //结点值的类型
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[MaxSize];

下面是用 BiTree 存储图 2-1 中二叉树的 C 语言代码：

#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(void) {
    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;

执行结果是：

按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:1 2 0 3 #
结点3的双亲结点的值为 2
结点2的左孩子的值为 3
当前结点没有右孩子

推荐阅读：
https://zhuanlan.zhihu.com/p/404837352
http://data.biancheng.net/view/314.html