数据结构：树

一、数的定义

现实生活中，有很多一对多的情况需要处理，所以我们需要研究这种一对多的数据结构——“树”，考虑到它的各种特性，来解决在编程中碰到的相关问题。

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

树的定义其实就是我们在栈时提到的递归的方法。也就是在树的定义之中还用到了树的概念，这是一种比较新的定义方法。

关于数的定义还需要强调两点：

1. n > 0时根结点是唯一的，不可能存在多个根节点。
2. m > 0时，子树的个数没有限制，但它们一定是互不相交的。

1.结点分类

树的结点包含一个数据元素及若干指向其子树的分支，结点拥有的子树称为结点的度（Degree）。
度为0的结点称为叶节点(Leaf)或终端结点；
度不为0的结点称为非终端结点或者分支节点。
除根节点之外，分支结点也称为内部结点。
树的度是树内各结点的度的最大值。

2.结点间的关系

结点的子树的根称为结点的孩子（Child），相应的，该结点称为孩子的双亲（Parent）。
同一个双亲的孩子之间互称兄弟（Sibling）.
结点的祖先是从根到该结点所经分支上的所有结点。
反之，以某结点为根的子树中的任意结点都称为该结点的子孙。

3.树的其他相关概念

结点的层次(Level)从根开始定义起，根为第一层，根的孩子为第二层。
双亲在同一层的结点互称为堂兄弟。
树中最大的层次称为树的深度（Depth）或高度。

如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。
森林(Forest)是m(m≥0)棵不相交的集合。对于树中的每个结点而言，其子树即为森林。

对比线性表和树的结构，它们有很大不同：

线性结构	树结构
第一个数据元素:无前驱	根节点:无双亲
最后一个数据元素:无后继	叶结点:无孩子,可以多个
中间元素:一个前驱一个后继	中间结点:一个双亲多个孩子

二、树的抽象数据类型

相对于线性结构，树的操作就完全不同了，这里我们给出一些基本和常用的操作。

ADT 树(tree)
Data
    树是由一个根节点和若干棵子树构成。树中结点具有相同数据类型及层次关系。
Operation
    InitTree(*T):构造空树T。
    DestroyTree(*T):销毁树T。
    CreateTree(*T,definition):按definition中给出树的定义来构造树
    ClearTree(*T):若树T存在，则将树T情况为空树
    TreeEmpty(T):若T为空树，返回true，否则返回false。
    TreeDepth(T):返回T的深度。
    Root(T):返回T的根结点
    Vlaue(T,cur_e):cur_e是树T中的一个结点，返回此节点的值
    Assign(T,cur_e,value):给树T的结点cur_e赋值为value
    Parent(T,cur_e):若cur_e是树T的非根节点，则返回它的双亲，否则为空
    LeftChild(T,cur_e):若cur_e是树T的非叶结点，则返回它的左孩子,否则返回空
    RightSibling(T,cur_e):若cur_e有右兄弟，则返回它的有兄弟，否则为空
    InsertChild(*T,*p,i,c):其中p指向树T的某个结点，i为所指结点p的度加上1，非空树c与T不相交，操作结果为插入c为树T中p指结点的第i棵子树。
    DeleteChild(*T,*p,i):若p指向树T的某个结点，i为所指结点p的度，操作结果为删除T中p所指结点的第i棵子树。

3.树的存储结构

存储结构分为顺序存储结构和链式存储结构。

先来看顺序存储结构，用一段地址连续的存储单元依次存储线性表的数据元素。这对于线性表来说是很正常的，但对于树这种一对多的结构呢？

树中某个结点的孩子可以有多个，这就意味着，无论按和中央顺序将树中所有结点存储到数组中，结点的存储位置都无法直接反应逻辑关系。数据元素挨着存储，就无法反应谁是谁的双亲，谁是谁的孩子。简单的顺序存储结构是不能满足树的实现要求的。

不过充分利用顺序存储和链式存储结构的的特点，完全可以实现对树的存储结构的表示。我们这里介绍3种不同的表示法：双亲表示法、孩子表示法、孩子兄弟表示法。

1.双亲表示法

有些人可能因为种种原因没有孩子，但是无论谁都一定有父母。树这种结构也不例外，除了根节点外，其余每个结点，它不一定有孩子，但是一定有且仅有一个双亲。

我们假设以一组连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点在数组中的位置。也就是说，每个结点除了知道自己是谁以外，还知道它的双亲在哪里。它的结点结构如表所示。

data	parent

其中data是数据域，存储结点的数据信息。而parent是指针域，存储该结点的双亲在数组中的下标。

以下是我们的双亲表示法的结点结构定义代码。

//树的双亲表示法结点结构定义
#define MAX_TREE_SIZE 100
typedef int TElemType;//树结点的数据类型，目前暂定为整型
typedef struct PTNode //结点结构
{
    TElemType data;//结点数据
    int parent;    //双亲位置
}PTNode;
typedef struct     //树结构
{
    PTNode nodes[MAX_TREE_SIZE];
    int r,n;//根的位置和结点数
}PTree;

有了这样的结构定义，我们就可以来实现双亲表示法了。由于根节点是没有双亲的，所以我们把根节点的位置域设为-1，这意味着，我们所有的结点都存有它双亲的位置。

下标	data	parent
0	A	-1
1	B	0
2	C	0
3	D	1
4	E	2
5	F	2
6	G	3
7	H	3
8	I	3
9	J	4

这样的存储结构，我们可以根据parent指针很容易找到它的双亲结点，所用的时间复杂度是O(1)，直到parent为-1时，找到了树节点的根。
如果我们要知道结点孩子是什么，得遍历整个结构才行，时间复杂度为O(n)。
这真是麻烦，于是我们改进一下。
我们增加一个结点最左边孩子的域，不妨叫它长子域，这样可以很容易得到结点的孩子。如果没有孩子的结点，这个长子域就设置为-1。

下标	data	parent	firstchild
0	A	-1	-1
1	B	0	3
2	C	0	4
3	D	1	6
4	E	2	9
5	F	2	-1
6	G	3	-1
7	H	3	-1
8	I	3	-1
9	J	4	-1

对于有0个或1个孩子结点来说，这样的结点解决了找结点孩子的问题。

另外一个问题场景，我们很关心，各兄弟之间的关系，双亲表示法无法体现这样的关系，那我们怎么办？
恩，我们可以增加一个右兄弟域来体现兄弟关系，也就是说，每个结点如果存在右兄弟，则记录下右兄弟的下表。同样，如果不存在，赋值为-1。

下标	data	parent	rightsib
0	A	-1	-1
1	B	0	2
2	C	0	-1
3	D	1	-1
4	E	2	5
5	F	2	-1
6	G	3	7
7	H	3	8
8	I	3	-1
9	J	4	-1

如果结点的孩子很多，超过了两个我们又关注结点的双亲，有关注结点的孩子，还关心结点的兄弟，而且对时间遍历要求比较高，那么我们还可以把此结构扩展为有双亲域、长子域、再有右兄弟域。存储结构的设计时一个非常灵活的过程。一个存储结构设计得是否合理，取决于该存储结构的运算是否合适、是否方便，时间复杂度好不好等…

2.孩子表示法

换一种完全不同的考虑方法。由于树中的每个结点可能有多棵子树，可以考虑用多重链表，即每个结点有多个指针域，其中每个指针指向一棵子树的根节点，我们把这种方法叫做多重链表表示法。不过，树的每个结点的度，也就是它的孩子个数是不同的，所以可设计两种方案来解决。

方案一

一种是指针域的个数就等于树的度，复习一下，树的度是树各个结点度的最大值。其结构如下所示。

data	child1	child2	child3	….	childd

其中data是数据域，child1到childd是指针域，用来指向该结点的孩子结点。

这种方法对于树中各结点度相差很大时，显然是很浪费空间的，因为有很多的结点，它的指针域都是空的。不过如果树的各结点度相差很小时，那就意味着开辟的空间被充分利用了，这时存储结构的缺点反而变成了优点。

既然多指针域都可能为空，为什么不按需分配呢。于是有了第二章方案。

方案二

第二章方案每个结点指针域等于该结点的度，我们专门去一个位置来存储结点指针域的个数。

data	degree	child1	child2	child3	….	childd

其中data为数据域，degree为度域，也就是存储该结点的孩子结点的个数，child1到childd为指针域，指向该结点的各个孩子的结点。

这种方法客服了浪费空间的缺点，对空间利用率是提高了，但是由于各个几点的链表是不相同的结构，加上要维护结点的度的数值，在运算上会带来时间的损耗。

能否有更好的办法，既可以减少空指针的浪费又能使结点结构相同。

仔细观察发现，我们为了要遍历整棵树，把每个结点放到一个顺序存储结构的数组中是合理的，但每个结点的孩子有多少是不确定的，所以我们再对每个结点的孩子建立一个单链表体现它们的关系。

这就是我们要讲的孩子表示法。具体方法时，把每个结点的孩子结点排列起来，以单链表作存储结构，则n个结点由n个孩子链表，如果是叶子结点则此单链表为空。然后n个头指针又组成一个线性表，采用顺序存储结构，存放进一个一维数组中。

为此设计两种结点结构，一个是孩子链表的孩子结点。
| child | next |
| ————- |:————-|
其中child是数据域，用来存储某个结点在表头数组中的下标。next是指针域，用来存储执行某节点的下一个孩子结点的指针。

另一个是表头数组的表头结点，
| data | firstchild |
| ————- |:————-|
其中data是数据域，存储某结点的数据信息。firstchild是头指针域，存储该结点的孩子链表的头指针。

以下是代码

//树的孩子表示法结构定义
#define MAX_TREE_SIZE 100
typedef struct CTNode //孩子结点
{
    int child;
    struct CTNode *next;
}*ChildPtr;

typedef struct//表头结构
{
    TEeleType data;
    ChildPtr firstchild;
}CTBox;
typedef struct
{
    CTBox nodes[MAX_TREE_SIZE];//结点数组
    int r,n;//根的位置和结点数
}CTree;

这样的结构对于我们查找某个结点的某个孩子，或者找某个结点的兄弟，只需要查找这个结点的孩子单链表即可。对于遍历整棵树也是很方便的，对头结点进行循环即可。

但是这也存在问题如何知道某个结点的双亲是谁呢？难道不可以把双亲表示法和孩子表示法结合一下么，当然是可以的，我们把这种方法称为双亲孩子表示法，应该是孩子表示法的改进。这里跳过具体定义。

3.孩子兄弟表示法

如果我们站在兄弟的角度考虑又如何？
对于树这样的层级结构来说，只研究结点的兄弟是不行的，我们观察后发现，任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此节点的右兄弟。
结点结构如表所示。

data	firstchild	rightsib

结构定义如下。

//树的孩子兄弟表示法结构定义
typedef struct CSNode
{
    TElemType data;
    struct CSNode *firstchild,*rightsib;
}CSNode,*CSTree;

这种表示法，给查找某个结点的孩子带来了方便，只需要通过firstchild找到此节点的长子，然后通过长子结点的rightsib找到它的二弟，接着一直下去，直到找到具体的孩子。当然如果想要找某个结点的双亲，这个表示法也是有缺陷的，那么怎么办呢？

如果真的有必要，完全可以再增加一个parent指针域来解决快速查找双亲的问题。

其实这个表示法的最大好处就是把它一棵复杂的树变成了一棵二叉树。

这样就可以充分利用二叉树的特性和算法来处理这棵树了。

四、二叉树的定义

二叉树（Binary Tree）是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根节点的左子树和右子树的二叉树组成。

1.二叉树的特点

1. 每个结点最多有两颗子树，所以二叉树中不存在大于2的结点。注意是最多有2棵子树。没有子树或者有一颗子树都是可以的。
2. 左子树和右子树是有顺序的，次序不能颠倒。就像左右手。
3. 即使树中某结点只有一棵子树，也要区分是左子树还是右子树。

二叉树具有五种基本形态：
1. 空二叉树
2. 只有一个根节点
3. 根节点只有左子树
4. 根节点只有右子树
5. 根节点既有左子树又有右子树

如果是有三个结点的数，有几种形态？如果是有三个结点的二叉树，又有几种形态？

如果是无序的数，只有两种，一种是一个根节点，下面2个子树。
另一种是一个根节点有一个子树，这个子树还有一个子树。

但是二叉树一定会有顺序，所以就演变成了5种。

2.特殊二叉树

1.斜树

顾名思义，斜树一定是要斜的，但是往哪斜还是有讲究。所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫做右斜树。这两者统称为斜树。斜树有很明显的特点，就是每一层只有一个结点，结点的个数与二叉树的深度相同。

有人说，这与线性表不是一样的么。对的，其实线性表结构就可以理解为是树的一种极其特殊的表现形式。

2.满二叉树

在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子结点都在同一层上，这样的二叉树称为满二叉树。

单是每个结点都存在左右子树，不能算是满二叉树，还必须要所有叶子都在同一层上，这就做到了整棵树的平衡。因此，满二叉树的特点有：

1. 叶子只能出现在最下一层。出现在其他层就不可能达成平衡
2. 非叶子结点的度一定是2。
3. 在同样深度的二叉树中。满二叉树的结点树最多，叶子数最多。

3.完全二叉树

对一棵具有n个结点的二叉树按层序编号，如果编号为i(1 ≤ i ≤ n)的结点和同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树被称为完全二叉树。

首先要从字面上进行区分，“完全”和“满”的差异，满二叉树一定是一棵完全二叉树，但完全二叉树不一定是满的。

其次，完全二叉树的所有结点与同样深度的满二叉树，它们按层序编号相同的结点，是一一对应的。这里有个关键词是按层序编号。

这里可以得出一些完全二叉树的特点：

1. 叶子结点只能出现在最下两层
2. 最下层的叶子节点一定集中在左部连续位置
3. 倒数第两层，若有叶子结点，一定都在右部连续位置
4. 若结点度为1，则该结点只有左孩子，即不存在只有右子树的情况
5. 同样结点树的二叉树，完全二叉树的深度最小。

五、二叉树的性质

1.二叉树性质1

性质1：在二叉树的第i层上至多有2^(i - 1)个结点(i ≥ 1)

2.二叉树性质2

性质2：深度为k的二叉树至多有2^k - 1个结点(k ≥ 1)
这里要和看清楚，是2^k后再减去1。

3.二叉树性质3

性质3：对任何一个二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0 = n2 + 1。

推导：假设度为1的结点数为n1，则n = n0 + n1 + n2。
又树的分支线总数的关系为 n - 1 = n1 + 2 * n2。
两者集合得出，n0 = n2 + 1。

4.二叉树性质4

性质4：具有n个结点的完全二叉树的深度为[log2n] + 1( [x]表示不大于x的最大整数 )。

5.二叉树性质5

性质5：如果对一棵有n个结点的完全二叉树（其深度为[log2n] + 1）的结点按层序编号（从第i层到第[log2n] + 1层，每层从左到右），对任一结点i(1 ≤ i ≤ n)有：

1. 如果i = 1，则结点i是二叉树的根，无双亲； 如果i > 1，则其双亲结点是 [i / 2]。
2. 如果2i > n，则结点i无左孩子（结点i为叶子节点）；否则其左孩子是结点2i
3. 如果2i + 1 > n，则结点无右孩子；否则其右孩子是结点2i + 1。

六、二叉树的存储结构

1.二叉树顺序存储结构

前面我们说过数的存储结构，并且谈到顺序存储对树这种一对多的关系结构实现起来是比较困难的。但是二叉树是一种特殊的树。由于它的特殊性，使用顺序存储结构也可以实现。

二叉树顺序存储结构就是用一维数组存储二叉树中的结点，并且结点存储位置，也就是数组的下表要能体现结点的逻辑关系。

由于二叉树定义的严格，所以用顺序存储结构也可以表现出二叉树的结构来。

但是对于一般的二叉树，尽管层序编号不能反映逻辑关系，但是可以将其完全二叉树编号，只不过，把不存在的结点设置为 “^”而已，表示不存在。

但是考虑一种极端的情况，比如一棵深度为k的右斜树，只有k个结点，但是需要分配2^k - 1个空间，这显然造成了空间的浪费。

2.二叉链表

既然顺序存储适用性不强，我们考虑链式存储结构。二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。

lchild	data	rchild

其中data是数据域，lchild和rchild都是指针域，分别存放在左孩子和右孩子的指针。

下面是二叉链表结构定义。

typedef struct BiTNode //结点结构
{
    TElemType data;
    struct BitNode *lchild ,*rchild;//左右孩子指针
}BiTNode,*BiTree;

如果有需要，还可以增加一个指向其双亲的指针域，那样就称之为三叉链表。

七、遍历二叉树

1.二叉树遍历原理

二叉树的遍历（traversing binary tree）是指从根节点出发，按照某种次序一次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

这里有两个关键字：访问和次序。
访问其实要根据实际的需要来确定具体做什么，比如对每个结点进行相关计算，输出打印等，它算作一个抽象操作。在这里我们假定是输出结点的数据信息。

二叉树的遍历次序不同于线性结构。树的结点之间不存在唯一的前驱和后继关系，在访问一个结点后，下一个被访问的结点面临不同的选择。

2.二叉树遍历方法

1.前序遍历

规则是若二叉树为空，则空操作返回，否则先访问根节点，然后前序遍历左子树，再前序遍历右子树。

2.中序遍历

规则是若树为空，则空操作返回，否则从根节点开始（注意并不是先访问根节点），中遍历根节点的左子树，然后是访问根节点，最后中序遍历右子树。

3.右序遍历

规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根节点。

4.层序遍历

规则是若树为空，则空操作返回，否则从树的第一层，也就是根节点开始访问，从上而下逐层遍历。

对于计算机来说，它只有循环、判断等方式来处理，也就是说，它只会处理线性序列，而我们刚才提到的四种遍历方法，其实都是把树中的结点变成某种意义的线性序列，这就给程序的实现带来了好处。

另外不同的遍历提供了对结点一次处理的不同方式，可以在遍历过程中对结点进行各种处理。

3.前序遍历算法

二叉树的定义是用递归的方式，所以，实现遍历算法也可以采用递归，而且机器简洁明了。
先来看二叉树的前序遍历算法。
代码如下：

//二叉树的前序遍历递归算法
void PreOrderTraverse(BiTree T)
{
    if(T == NULL)
        return;
    println("%c",T->data);//显示结点数据，可以更改为其他操作
    PreOrderTraverse(T->lchild);//再先序遍历左子树
    PreOrderTraverse(T->rchild);//最后先序遍历右子树
}

4.中序遍历算法

那么中序遍历算法如何呢?

//二叉树的中序遍历算法
void InOrderTraverse(BiTree T)
{
    if(T == NULL)
        return;
    InOrderTraverse(T->lchild);//中序遍历左子树
    printf("%c",T->data);//显示结点数据，可以更改为其他对操作
    InOrderTraverse(T->rchild);//最后中序遍历右子树
}

换句话说，它等于时把调用左孩子的递归函数提前了。就这么简单。

5.后序遍历算法

那么同样的，后序遍历算法也很容易想到如何写代码了。

//二叉树的后续遍历递归算法
void PostOrderTraverse(BiTree T)
{
    if(T == NULL)
        return;
    PostOrderTraverse(T->lchild);//后续遍历左子树
    PostOrderTraverse(T->rchild);//后序遍历右子树
    printf("%c",T->data);//显示结点数据，可以更改为其他操作
}

6.推导遍历结果

已知一棵二叉树的前序遍历为ABCDE，中序遍历为CBAEDF，请问这棵二叉树的后续遍历是多少？
如果真的了解前中后序的原理，是不难的。

因为前序遍历第一个字母是A，就说明A是根节点。又因为后序遍历是CBAEDF，可以知道C和B是A的左子树的结点，E、D、F是A的右子树的结点。

然后我们看前序中的C和B，它的顺序是ABC，是先打印B后打印C，所以B应该是A的左孩子，而C就只能是B的孩子。此时是左还是右还不确定，再看中序序列是CBAEDF，C是在B的前面打印，说明C是B的左孩子。

再看前序中的E、D、F，它的顺序是DEF，意味着D是A结点的右孩子，E和F都是D的子孙。再看中序序列EDF，E在D的左侧，而F在右侧，可以确定E是D的左孩子，F是D的右孩子。
最终后序遍历结果是CBEFDA。

如果是已知中序遍历顺序和后续遍历顺序，求前序遍历，同理。

从这里我们也得到两个二叉树遍历的性质。

• 已知前序遍历和中序遍历序列，可以唯一确定一棵二叉树。
• 已知后序遍历和中序遍历序列，可以唯一确定一棵二叉树。

但要注意了，已知前序遍历和后续遍历，是不能确定一棵二叉树的。比如前序是ABC，后序是CBA，我们只能确定A是根节点。

八、二叉树的建立

下面我们来建立一个二叉树。
假设现在我们要构造一个4个结点的二叉树，根节点为A，根节点的左节点为B，根节点的右节点是C，B的右节点是D。
如果我们要在内存中建立这样的一棵二叉树，为了能让每个结点确认是否有左右孩子，我们对它进行了扩展，也就是让二叉树中的每个结点的空指针引出一个虚节点，其值为一特定值，比如“#”。我们称这种处理后的二叉树为原二叉树的扩展二叉树。扩展二叉树就可以做到一个遍历序列确定一棵二叉树。比如前面所说的前序遍历序列就为AB#D##C##。

有了这样的准备，我们就可以来看看如何生成一棵二叉树了。假设结点均为一个字符，我们把公共前序遍历序列AB#D##C##用键盘挨个输入。实现如下：

//按前序输入二叉树中的节点值
//#表示空树，构造二叉链表表示为二叉树T
void CreateBiTree(BiTree *T)
{
    TElemType ch;
    scanf("%c",&ch);
    if(ch == '#')
        *T = NULL;
    else
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data = ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}

其实建立二叉树，也是用了递归的原理。只不过在原来应该是打印结点的地方，改成了生成结点，给结点赋值的操作而已。

当然，也可以用中序遍历或后序遍历方式建立二叉树，只不过代码里的生成结点和构造左右二叉树的顺序交换一下。输入的字符也饿要做相应的更改。

九、线索二叉树

1.线索二叉树原理

前序遍历ABDHIEJCFG
中序遍历HDIBJEAFCG
这样一颗二叉树，我们首先来看这空指针有多少个呢？
对于一个有n个结点的二叉链表，每个结点由指向左右孩子的两个指针域，所以一共是2n个指针域。而n个结点一共有n - 1条分支线，其实是存在2n - (n - 1) = n + 1个空指针域。

另一方面，我们在做遍历时，比如得到了HDIBJEAFCG这样的结果，通过遍历后，我们知道结点I的前驱是D，后继是B，结点F的前驱是A，后继是C，也就是说，我们可以很清楚地知道任意一个结点的前驱和后继是哪一个。

可是这是建立在已经遍历的基础之上的。在二叉链表上，我们只能知道每个结点指向其左右孩子结点的地址，而不知道某个结点的前驱是谁，后继是谁，想要知道就必须遍历一次。为什么不考虑在创建时就记住这些前驱和后继呢？

综上两个角度的分析，我们可以考虑使用那些空地址，存放指向结点在某种遍历次序下的前驱和后继结点的地址。我们把这种指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树（Thread Binary Tree）。

我们把这棵二叉树进行中序遍历后，将所有的空指针域中的rchild，改为指向它的后继结点。
我们把这棵二叉树所有的空指针域的lchild，改为指向当前结点的前驱。

其实通过线索二叉树，等于是把一棵二叉树转变成了一个双向链表，这样对我们的插入删除结点、查找某个结点都带来了方便，所以我们对二叉树以某种次序遍历使其变为线索二叉树的过程称作是线索化。

但是我们如何知道某一结点的lchild是指向它的左孩子还是指向前驱，rchild是指向右孩子还是指向后继？比如E的结点的lchild指向他的左孩子J，而rchild是指向它的后继A。显然我们在决定lchild是指向左孩子还是前驱，rchild是指向右孩子还是后继需要一个区分标志的。因此，我们在每个结点再增设两个标志域ltag和rtag，注意ltag和rtag只是存放0和1数字。
结构如下所示。

lchild	ltag	data	rtag	rchild

①ltag为0时指向该结点的左孩子，为1时指向该结点的前驱

②rtag为0时指向该结点的右孩子，为1时指向该结点的后继

2.线索二叉树结构实现

由此二叉树线索存储结构定义代码如下：

//二叉树的二叉线索存储结构定义
typedef enum{Link,Thread} PointerTag;//Link==0表示左右孩子指针
                            //Thread==1表示指向前驱或后继的线索
typedef struct BiThrNode
{
    TElemType data;//结点数据
    struct BiThrNode *lchild, *rchild;//左右孩子指针
    PointerTag LTag;
    PointerTag RTag;//左右标识
}BiThrNode , *BiThrTree;

线索化的实质就是将二叉链表中的空指针改为指向前驱或后继的线索。由于前驱和后继的信息只有在遍历该二叉树时才能得到，所以线索化的过程就是在遍历的过程中修改空指针的过程。

中序遍历线索化的递归函数代码如下：

BiThrTree pre;//全局变量，始终指向刚刚访问过的结点
//中序遍历进行中序线索化
void InThreading(BiThrTree p)
{
    if(p)
    {
        InThreading(p->lchild);//递归左子树线索化
        if(!p->lchild)//没有左孩子
        {
            p->LTag = Thread;//前驱线索
            p->lchild = pre;//左孩子指针指向前驱
        }
        if(!pre->rchild)
        {
            pre->RTag = Thread;//后继线索
            pre->rchild = p;//前驱右孩子指针指向后继(当前结点p)
        }
        pre = p;//保持pre指向p的前驱
        InThreading(p->rchild);;//递归右子树线索化
    }
}

你会发现，这段代码和二叉树的中序遍历代码几乎完全一样，只不过将本是打印结点的功能改成了线索化的功能。

if(!p->lchild)表示如果某结点的左指针域为空，因为其前驱结点刚刚访问过赋值给了pre，所以可以将pre赋值给p->lchild，并修改p->LTag = Thread（也就是定义为1）以完成前驱结点的线索化。

后继就要稍稍麻烦点。因为此时p结点的后继结点还没有访问到，因此只能对它的前驱结点pre的右指针rchild做判断，if(!pre->rchild)表示如果为空，则p就是pre的后继，于是pre->rchild = p,并且设置pre->RTag = Thread，完成后继结点的线索化。

有了线索二叉树之后，我们对它进行遍历时发现，其实就等于操作一个双向链表结构。

和双向链表结构一样，在二叉树线索链表上添加一个头结点，并令其lchild域的指针指向二叉树的根节点，其rchild域的指针指向中序遍历时访问的最后一个结点。反之，零二叉树的中序序列中的第一个结点中,lchild域指针和最后一个结点的rchild域指针，都指向头结点。这样的好处就是我们既可以从第一个结点起顺后进行遍历，也可以从最后一个结点其前驱进行遍历。

遍历代码如下：

//T指向头结点，头结点左链lchild指向根节点，头结点右链指向中序遍历的
//最后一个结点，中序遍历二叉线索表表示的二叉树T
Status InOrderTraverse_Thr(BiThrTree T)
{
    BiThrTree p;
    p = T->lchild;//p指向根节点
    while(p != T)//空树或者遍历结束时, p == T
    {
        while(p->LTag == Link)
            p = p->lchild;
        printf("%c",p->data);//显示结点数据
        while(p->RTag == Thread && p->rchild != T)
        {
            p = p->rchild;
            printf("%c",p->data);
        }
        p = p->rchild;//p进其右子树根
    }
    return OK;
}

这段代码可以看出，它等于时一个链表的扫描，所以时间复杂度为O(n)。
由于它重复利用了空指针域的空间，又保证了创建时的一次遍历就可以终生受用的前驱后继的信息。所以在实际问题中，如果所用二叉树经常需要遍历或查找结点时需要遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构是非常不错的选择。

十、树、森林与二叉树的转换

我们前面已经讲过了树的定义和存储结构，对于树来说，在满足树的条件下可以是任意形状，一个结点可以有多个孩子，显然对树的处理要复杂的多，去研究关于树的性质和算法，真的不如。有没有简单的办法解决对树处理的难题呢？

我们前面也讲了二叉树，尽管它也是树，但由于每个结点最多只能有左孩子和右孩子，面对的变化就少很多了。因此很多性质和算法都被研究了出来。如果所有的树都像二叉树一样方便就好了。

在讲树的存储结构时，我们讲到了树的孩子兄弟表示法可以将一棵树用二叉链表进行存储，所以借助二叉链表、树和二叉树可以相互转换。从物理结构来看，它们的二叉链表也是相同的，只是解释不太一样而已。因此，只要我们设定一定的规则，用二叉树来表示树，甚至表示森林都是可以的，森林和二叉树也可以互相进行转换。

1.树转换为二叉树

将树转换为二叉树的步骤如下：

1. 加线。在所有兄弟结点之间加一条连线。
2. 去线。对树中每个结点，只保留它与第一个孩子结点的连线，删除它与其他孩子结点之间的连线。
3. 层次调整。以树的根节点为轴心，将整棵树顺时针旋转一定的角度，使之层次分明。

2.森林转换为二叉树

森林是由若干棵树组成的，可以理解为，森林中第一棵树都是兄弟可以嗷嗷兄弟的处理办法来操作。步骤如下：

1. 把每棵树转换为二叉树
2. 第一棵二叉树不懂，从第二棵二叉树开始，一次把后一棵二叉树的根节点作为前一棵二叉树的根节点的右孩子，用线连接起来。当所有的二叉树连接起来后就得到了由森林转换而来的二叉树

3.二叉树转换为树

可以把这个过程认为是树转换为二叉树的逆过程。
步骤如下：

1. 加线。若某节点的左孩子结点存在，则将这个左孩子的右节点、右孩子的右节点、右孩子的右孩子的右孩子结点……反正就是左孩子的n个右孩子结点都作为此结点的孩子。将该结点与这些右孩子结点用线连接起来
2. 去线。删除原二叉树中所有结点与其右孩子结点的连线。
3. 层次调整

4.二叉树转换为森林

判断一棵二叉树能够转换成一棵树还是森林，标准很简单，那就是只要看这棵二叉树根节点有没有右孩子，没有就是一棵树。
那么如果是转换成森林，步骤如下：

1. 从根节点开始，若右孩子存在，则把与右孩子结点的连线删除，再看分离后的二叉树，若右孩子存在，则连线上拿出……，直到所有右孩子连线都删除为止，得到分离的二叉树。
2. 再将每棵二叉树转换为树就可以

5.树与森林的遍历

树的遍历分为两种方式。

1. 一种是先根遍历树，即先访问树的根节点，然后依次遍历根的每棵子树。
2. 另一种是后根遍历，即先依次后根遍历每棵子树，然后访问根节点。

森林的遍历也分为两种方式：

1. 前序遍历：先访问森林中第一棵树的根节点，然后再依次先根遍历每棵子树，再依次用同样的方式遍历除去第一棵树的剩余树构成的森林。
2. 后序遍历：是先访问森林中的第一课树，后根遍历方式遍历每棵子树，然后再访问根节点，在依次同样方式遍历取出第一棵树的剩余树构成的森林。

我们发现，森林的前序遍历和二叉树的前序遍历结果相同，森林的后序后序遍历和二叉树的中序遍历结果相同。

这也就告诉我们，当以二叉链表作树的存储结构时，树的先根遍历和后根遍历完全可以借用二叉树的前序遍历和中序遍历算法来实现。这也其实就证实，我们找到了对树和森林这种复杂问题的简单解决办法。

十一、赫夫曼树及其应用

1.赫夫曼树

在生成火种，我们经常会使用到压缩和解压缩软件来处理文档。因为它除了可以减少文档在磁盘上的空间之外，还有重要的一点，就是我们可以在网络上以压缩的形式传输大量数据，使得保存和传递都更加高效。

那么压缩而不出错是如何做到的呢？简单地来说，就是我们要压缩的文本进行重新编码，以减少不必要的空间。尽管最新的编码已经很好很强大，但这一切都来自于曾经的技术积累，我们就介绍最基本的压缩编码的方法——赫夫曼编码。

在介绍赫夫曼编码前，我们必须得介绍赫夫曼树，它的编码方法称为赫夫曼编码。

过去我们小学、中学一般考试都是用百分制来表示学科成绩的。这带来一个弊端，就是让学生、家长，甚至老师都以分取人。所以后面出了五级分制的成绩。但是一般都是先按照百分之算出成绩后，再根据统一的标准换算。

if(a < 60)
    b = "不及格";
else if(a < 70)
    b = "及格";
else if(a < 80)
    b = "中等";
else if(a < 90)
    b = "良好";
else
    b = "优秀";

粗略看没问题，可是通常都认为，一张好的考卷应该是让学生成绩大部分处于中等或良好的范围。优秀和不及格都应该较少才对。而上面这样的程序。就使得所有的成绩都需要先判断是否及格，再逐级而上得到结果。输入量很大的时候，其实算法是有效率问题的。

假设实际中，学生的成绩在5个等级上的分布规律如表所示。

分数	0~59	60~69	70~79	80~89	90~100
所占比例	5%	15%	40%	30%	10%

那么70分以上大约占总数的80%的成绩都需要经过3次以上的判断才能得到结果，这显然不合理。

有没有好一些办法，仔细观察发现，中等成绩（70~79分之间）比例最高，其次是良好成绩，不及格所占比例最少。

2.赫夫曼树定义与原理

1.赫夫曼树定义与原理

从树中一个结点到另一个结点之间的分支结构构成两个结点的路径，路径上的分支数目称做路径长度。

路径的长度就是从树根到每一结点的路径长度之和。

如果考虑到带权的结点，结点的带权路径长度为从该结点到树根之间的路径长度与结点上权的成绩。树的带权路径长度为树中所有叶子结点的带权路径长度之和。假设有n个权值{w1,w2,…,wn}，构造一棵树有n个叶子节点的二叉树，每个叶子节点的带权wk，每个叶子的路径长度为lk，我们通常记作，则其中带权路径长度WPL最小的二叉树称作赫夫曼树。也有不少树称作最优二叉树。

通过刚才的步骤，我们可以得出构造赫夫曼树算法描述。

1. 根据给定的n个权值{w1,w2,…..,wn}构成n棵二叉树的集合F={T1,T2,…,Tn}，其中每棵二叉树只有一个带权为w1的根节点，其左右子树均为空
2. 在F中选取两个根节点权值最小的树作为左右子树构成一棵新的二叉树，且置信的二叉树的根节点的权值为其左右子树上根节点的权值之和。
3. 在F中删除这两棵树，同时将新得到的二叉树加入F中
4. 重复2和3步骤，直到F只含一棵树为止，这棵树便是赫夫曼树。

2.赫夫曼编码

赫夫曼研究这种最优树的目的不是为了我们转换成绩。它的目的是为了解决当年远距离通信（主要是电报）的数据传输的优化问题。

比如我们有一段文字内容为“BADCADFEED”要网络传输给别人，显然用二进制数字（0和1）来表示是很正常的想法。我们在这段文字中只要六个字母ABCDEF，那么我们可以用相应的二进制数据表示。

字母	A	B	C	D	E	F
二进制字符	000	001	010	011	100	111

这样真正传输的数据就是编码后的
“00100000110100000000011101100100011”。如果一篇文章很长，这样的二进制串也将非常的可怕。而且事实上，不管是英文、中文或者其他语言，字母或汉子出现频率是不相同的，比如英语中的“a e i o u”，中文的“的 了 有 在”等汉子都是频率极高。

假设6个字母频率为A 27 , B 8 , C 15 , D 15 ,E 30 , F 5，合起来正好是100%，我们完全可以按照赫夫曼树来规划它们

然后我们对这六个字母用其树根到叶子所经过路径的0和1来编码，可以得到如表6-123所示这样的定义。

字母	A	B	C	D	E	F
二进制字符	01	1001	101	00	11	1000

原文字内容“BADCADFEED”再次编码，对比可以看到结果串变小了。

• 原编码二进制串：0010000110100000011101100100011(共30个字符)

• 新编码二进制串：1001010010101001000111100（共25个字符）

  也就是说，我们数据被压缩了，节约了大约17%的存储或传输成本，随着字符增多和字符权重的不同，这种压缩会更加明显。

当我们接受到1001010010101001000111100这样压缩过的新编码时，我们应该如何解码呢？

编码中非0即1，长短不等的话其实很容易混淆，所以若要设计长短不等的编码，则必须是任一字符的编码都不是另一个字符的编码的前缀，这种编码称作前缀编码。

你仔细观察发现，上面表格中的编码就不存在容易与1001、1000混淆的“10”和“100”编码。

可仅仅是这样不足以让我们方便地解码，因此在解码时，还是要用到赫夫曼树，即发送方和接收方必须要约定好同样的赫夫曼编码规则。

一般地，设需要编码的字符集为{d1,d2,……,dn}，各个字符在电文中出现的次数或频率集合为{w1,w2,…,wn}，以d1,d2,…,dn作为叶子结点，以w1,w2,…,wn作为相应叶子结点的权值来构造一棵哈夫曼树。规定哈夫曼树的左分支代表0，右分支代表1，则从根节点到叶子结点所经过路径分支组成的0和1的序列便为该结点对应的字符编码，这就是赫夫曼编码。