【计算机考研（408）- 数据结构】树与二叉树

树与二叉树

树的定义及相关概念

树 是n（n≥0）个结点的有限集合，n = 0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足：

1）有且仅有一个特定的称为根的结点。

2）当n > 1时，其余结点可分为m（m > 0）个互不相交的有限集合T1, T2,..., Tm，其中每个集合本身又是一棵树，并且称为根结点的子树 。

3）树的根结点没有前驱结点，其余结点有且仅有一个前驱结点。

4）树中所有结点可以有零个或多个后继结点。

树的基本术语

结点之间的关系描述：则有：祖先结点，子孙结点，双亲结点，孩子节点，兄弟结点，堂兄弟结点，以上完全可以按照树的结构和亲戚对应的关系很方便的区分。如图所示：

很明显地可以了解到：B的子孙有EFKL，路径上的ABE都是K的祖先结点，E是K的双亲（父结点），K是E的子孙结点（孩子），K和L具有相同的双亲E，因此K和L是兄弟结点。结点G和EFHIJ互为堂兄弟结点。（排得差不多了，自己领会吧）。

结点、树的属性描述：结点的层次（深度） ------从上往下数（从根到该节点的深度，例如B的深度为2），结点的高度 ------从下往上数，以该结点为根的子树的高度，例如D的高度为3，树的高度（深度） ------总共多少层，上图树高度为4，结点的度 ------有几个孩子（分支），B度为2，D度为3，树的度------各结点的度的最大值。

树中度大于0的结点为分支结点 ，度为0的结点为叶子结点。在分支结点中，每个结点的分支数就是该结点的度。

有序树 ------逻辑上看，树中结点的各子树从左至右是有次序的，不能互换。
无序树 ------逻辑上看，树中结点的各子树从左至右是无次序的，可以互换。
路径 ------路径是由两个节点之间所经过的结点序列构成的。
路径长度 ------所经过的边的个数。
森林------森林是m（m≥0）棵互不相交的树的集合。 ^ac8bfc

树的性质

证明我就不写了，留给我自己去推。

• 树中的结点数等于所有结点的度数加1（加的是根）
• 度为m的树中第i层至多有 m i − 1 m^{i-1} mi−1个结点
• 高度为h的m叉树至多有 ( m h − 1 ) / ( m − 1 ) (m^h-1)/(m-1) (mh−1)/(m−1)个结点
• 具有n个结点的m叉树的最小高度为 ⌈ l o g m ( n ( m − 1 ) + 1 ) ⌉ \lceil log_m(n(m-1)+1)\rceil ⌈logm(n(m−1)+1)⌉
• 度为m、具有n个结点的树最大高度为 n − m + 1 n-m+1 n−m+1
• 高度为h的m叉树至少有h个结点。高度为h、度为m的树至少有h+m-1个结点。

二叉树的定义及相关概念

二叉树 是n（n≥0）个结点的有限集合：

1）或者为空二叉树，即n = 0。

2）或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。

特点：1. 每个结点至多只有两棵子树 2. 左右子树不能颠倒（二叉树是有序树）。

二叉树和度为2的有序树的区别：

1. 度为2的有序树树至少有3个结点，而二叉树可以为空
2. 度为2的有序树的左右次序是相对于另一个孩子结点而言的，若某个结点只有一个孩子结点，则这个孩子结点就无须区分左右次序。而二叉树不一样。

几种特殊的二叉树

满二叉树

满二叉树：高度为h，且含有 2 h − 1 2^h-1 2h−1个结点。每层都含有最多的结点。除了叶子结点度都为2。

特点：

1. 只有最后一层有叶子结点
2. 不存在度为1的结点
3. 按层序从1开始编号，结点i的左孩子为2i，右孩子为2i+1；结点i的父节点为 ⌊ i / 2 ⌋ \lfloor i/2 \rfloor ⌊i/2⌋（如果有的话）

示例图：

完全二叉树

完全二叉树：当且仅当其每个结点都与高度为h的满二叉树中编号为1～n的结点一一对应时，称为完全二叉树。

有n个结点。特点如下：

1. 若 i ≤ ⌈ n / 2 ⌉ i \leq \lceil n/2 \rceil i≤⌈n/2⌉，则结点 i i i 为分支结点，否则为叶子结点。
2. 只有最后两层才会出现叶子结点。
3. 最多只有一个度为 1 的结点（这种情况下该结点一定只有左孩子，没有右孩子）。
4. 按层序编号，若 i i i 结点为叶子结点或只有左孩子，则编号大于 i i i 的结点均为叶子结点。
5. 同满二叉树的3.特点。

示例图：

完全二叉树可以视作从满二叉树中删去若干最底层、最右边的一些连续叶节点所得到的二叉树。

平衡二叉树

平衡二叉树：任意结点的左右子树的深度之差不超过1。详见

二叉排序树

二叉排序树：左子树上所有结点均小于根结点的关键字；右子树所有结点均大于根结点的关键字。左子树和右子树个是一棵二叉排序树。详见

正则二叉树

正则二叉树：树中每个分支都有两个孩子，即树中只有度为0或2的结点。

二叉树的性质

以下推导过程略，自己推。

• 非空二叉树的叶子结点数等于度为2的结点数加1，即 n 0 = n 2 + 1 n_0=n_2+1 n0=n2+1
• 非空二叉树第i层最多有 2 i − 1 2^{i-1} 2i−1个结点->m叉树第i层最多有 m i − 1 m^{i-1} mi−1个结点
• 高度为h的二叉树至多有 2 h − 1 2^h-1 2h−1个结点（为一棵满二叉树）->高度为h的m叉树至多有 ( m h − 1 ) / ( m − 1 ) (m^h-1)/(m-1) (mh−1)/(m−1)个结点
• 具有n个结点的完全二叉树 的高度 ⌈ l o g 2 ( n + 1 ) ⌉ \lceil log_2(n+1)\rceil ⌈log2(n+1)⌉或 ⌊ l o g 2 n ⌋ + 1 \lfloor log_2n\rfloor+1 ⌊log2n⌋+1
• 若完全二叉树有2k个（偶数）个结点，则必有 n 1 = 1 n_1=1 n1=1， n 0 = k n_0 = k n0=k， n 2 = k − 1 n_2 = k-1 n2=k−1，若完全二叉树有2k-1个（奇数）个结点，则必有 n 1 = 0 n_1=0 n1=0， n 0 = k n_0=k n0=k， n 2 = k − 1 n_2=k-1 n2=k−1（突破点：完全二叉树最多只会有一个度为1的结点）

二叉树的存储结构

二叉树的顺序存储结构

顺序存储结构：用一组地址连续的存储单元一次自上而下、自左至右存储完全二叉树的结点元素。即完全二叉树编号为i的结点元素存储在某个数组下标为i-1的分量中。该结构对顺序二叉树和完全二叉树比较合适。这种存储结构要从数组下标1开始存储数中的结点。

二叉树的顺序存储中，一定要把二叉树的结点编号与完全二叉树对应起来，所以一定会有大量的空间被浪费掉。

基于以上特点如果用来存储满二叉树 和完全二叉树可能使用此方法较为适合。

二叉树的链式存储结构

由于顺序存储的空间利用率较低，所以我们一般都会采用链式存储结构。用链表结点来存储二叉树的每个结点。如图所示一个二叉树链式存储的结点结构。

二叉树的链式存储结构描述如下：

typedef struct BiTNode {
    ElemType data; // 结点数据
    struct BiTNode *lchild, *rchild; // 左右孩子指针
} BiTNode, *BiTree;

一颗二叉树及其所对应的二叉链表如图所示，展示了链式存储结构：

当然也很容易知道，含有n个结点的二叉链表中，含有n+1个空链域。这为后面的线索二叉树提供了方便。

二叉树的遍历

先序遍历

先序遍历：先访问根结点，然后先序遍历左子树，最后先序遍历右子树。

实现：

void PreOrderTraverse(BiTree T) {
    if (T == NULL) return; // 递归终止条件
    visit(T); // 访问根结点
    PreOrderTraverse(T->lchild); // 先序遍历左子树
    PreOrderTraverse(T->rchild); // 先序遍历右子树
}

中序遍历

中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树。

实现：

void InOrderTraverse(BiTree T) {
    if (T == NULL) return; // 递归终止条件
    InOrderTraverse(T->lchild); // 中序遍历左子树
    visit(T); // 访问根结点
    InOrderTraverse(T->rchild); // 中序遍历右子树
}

后序遍历

后序遍历：先后序遍历左子树，然后后序遍历右子树，最后访问根结点。

实现：

void PostOrderTraverse(BiTree T) {
    if (T == NULL) return; // 递归终止条件
    PostOrderTraverse(T->lchild); // 后序遍历左子树
    PostOrderTraverse(T->rchild); // 后序遍历右子树
    visit(T); // 访问根结点
}

层次遍历

层次遍历：从根结点开始，按层次顺序访问结点。

实现：

void LevelOrderTraverse(BiTree T) {
    if (T == NULL) return; // 递归终止条件
    Queue<BiTree> q;//这里需要用到一个辅助队列
    q.push(T);
    while (!q.empty()) {
        BiTree node = q.front();
        q.pop();
        visit(node);
        if (node->lchild != NULL) q.push(node->lchild);
        if (node->rchild != NULL) q.push(node->rchild);
    }
}

这里用到了之前已经学过的[[栈和队列#队列]]的知识，代码里面用到了C++的队列，如果是书上的，那么 push就是 EnQueue，pop就是 DeQueue。

算法效率分析与改造

不管是哪种算法，每个结点都访问一次且仅访问一次，故时间复杂度都是O(n)。

算法改造成为非递归算法时，通常需要借用[[栈和队列#栈]]一个来存储结点。如以下中序遍历改造所示：

// 中序遍历非递归算法，需要借用一个栈
void InOrder2(BiTree T){
    InitStack(S); 
    BiTree p=T;  // p是遍历指针
    while(p||!isEmpty(S)){
        if(p){
            Push(S,p);
            p=p->lchild;
        }
        else{
            Pop(S,p);
            visit(p);
            p=p->rchild;
        }
    }
}

利用遍历序列构造一个二叉树

给定先序遍历和中序遍历序列，可以唯一确定一棵二叉树。先序遍历的第一个元素是根结点，然后在中序遍历中找到根结点的位置，左边的部分是左子树，右边的部分是右子树。

同理，给定后序遍历和中序遍历序列，也可以唯一确定一棵二叉树。后序遍历的最后一个元素是根结点，然后在中序遍历中找到根结点的位置，左边的部分是左子树，右边的部分是右子树。

那么，给定层序和中序遍历，也可以唯一确定一棵二叉树。层序遍历的第一个元素是根结点，然后在中序遍历中找到根结点位置，左边的部分是左子树，右边的部分是右子树。

那么很显然，先序、后序、层序俩俩组合无法唯一确定一棵二叉树。

注：此节需要练习才能熟练掌握。

线索二叉树

传统的二叉树，每个结点有两个指针，分别指向左孩子和右孩子。不能直接得到结点在遍历过程中的前驱和后继结点。为了解决这个问题，引入了线索二叉树。

在前面的内容中我们知道:在含有n个结点的二叉树中，含有n+1个空链域。线索二叉树就是利用这些空链域来存储结点的前驱和后继信息。

线索二叉树规定：若无左子树，令lchild指向其前驱结点；若无右子树，令rchild指向其后继结点。如图所示为线索二叉树的结点结构

其中标志域lflag和rflag用来标识指针域是指向孩子结点还是前驱/后继结点。

{ lflag = 0 表示 l c h i l d 指向孩子结点 lflag = 1 表示 l c h i l d 指向前驱结点 rflag = 0 表示 r c h i l d 指向孩子结点 rflag = 1 表示 r c h i l d 指向后继结点 \begin{array}{l} \left\{ \begin{aligned} &\text{lflag}=0 \text{ 表示 } lchild \text{ 指向孩子结点} \\ &\text{lflag}=1 \text{ 表示 } lchild \text{ 指向前驱结点} \\ &\text{rflag}=0 \text{ 表示 } rchild \text{ 指向孩子结点} \\ &\text{rflag}=1 \text{ 表示 } rchild \text{ 指向后继结点} \\ \end{aligned} \right. \end{array} ⎩ ⎨ ⎧lflag=0 表示 lchild 指向孩子结点lflag=1 表示 lchild 指向前驱结点rflag=0 表示 rchild 指向孩子结点rflag=1 表示 rchild 指向后继结点

那么线索二叉树的存储结构描述如下：

typedef struct ThreadNode {
    ElemType data; // 结点数据
    struct ThreadNode *lchild, *rchild; // 左右孩子指针
    int lflag, rflag; // 标志域
} ThreadNode, *ThreadTree;

线索二叉树的构造：遍历一次二叉树，只是在遍历的过程中，检查当前结点的左右指针域是否为空，若为空，将它们改为指向前驱结点或后继结点的线索。代码：

// 创建中序线索二叉树
void CreateInThread(ThreadTree T) {
  ThreadTree pre = NULL; // pre用于记录当前结点的前驱
  if (T != NULL) {
    InThread(T, pre);      // 对二叉树进行中序线索化
    pre->rchild = NULL;    // 最后一个结点的后继线索置空
    pre->rtag = 1;         // rtag=1表示rchild为线索
  }
}

// 中序遍历递归线索化
void InThread(ThreadTree &p, ThreadTree &pre) {
  if (p != NULL) {
    InThread(p->lchild, pre); // 递归线索化左子树

    // 若左子树为空，则lchild指向前驱pre，ltag=1
    if (p->lchild == NULL) {
      p->lchild = pre;
      p->ltag = 1;
    }
    // 若前驱结点的右子树为空，则rchild指向当前结点，rtag=1
    if (pre != NULL && pre->rchild == NULL) {
      pre->rchild = p;
      pre->rtag = 1;
    }
    pre = p; // 更新前驱为当前结点

    InThread(p->rchild, pre); // 递归线索化右子树
  }
}

先序线索化：

void CreatePreThread(ThreadTree T) {
    ThreadTree pre = NULL; // pre用于记录当前结点的前驱
    if (T != NULL) {
        PreThread(T, pre);      // 对二叉树进行先序线索化
        if(pre->rchild == NULL) {//这里我有点疑问，可能他和中序线索化一样也不是不行，因为先和中的pre->rchild一定是NULL。
            pre->rtag = 1;      // rtag=1表示rchild为线索
        }
    }
}
// 先序遍历递归线索化
void PreThread(ThreadTree p, ThreadTree &pre) {
    if (p != NULL) { 
        //左子树为空，建立线索
        if(p->lchild == NULL){
          p->lchild = pre;
          p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL){
          pre->rchild = p;
          pre->rtag = 1;
        }
        pre = p;
        //我们前面介绍过，如果p的左子树为空，则建立p为左孩子，所以判断p的左子树代表的是否为线索
        if(p->ltag == 0) {
            PreThread(p->lchild, pre); // 递归线索化左子树
        }
        PreThread(p->rchild, pre); // 递归线索化右子树
    }
}

后序线索化：

void CreatePostThread(ThreadTree T) {
    ThreadTree pre = NULL; // pre用于记录当前结点的前驱
    if (T != NULL) {
        PostThread(T, pre);      // 对二叉树进行后序线索化
        if(pre->rchild == NULL) {
            pre->rtag = 1;      // rtag=1表示rchild为
        }
    }
}
// 后序遍历递归线索化
void PostThread(ThreadTree p, ThreadTree &pre) {
    if (p != NULL) {
        PostThread(p->lchild, pre);
        PostThread(p->rchild, pre);
        if (p->lchild == NULL) {
            p->ltag = 1;
            p->lchild = pre; // 左子树为空，建立线索
        }
        if (pre != NULL && pre->rchild == NULL) {
            pre->rtag = 1;
            pre->rchild = p;
        }
        pre=p;
    }
}

带有头结点的线索二叉树

如图（此为中序）：

他的指向关系在图中很明确，这样做的好处就是能够很方便的从前往后或者从后往前对线索二叉树进行一个遍历。

线索二叉树的遍历

线索二叉树的遍历：利用线索二叉树，可以实现二叉树遍历的非递归算法。

以中序遍历找后继为例，代码如下：

void Inorder(ThreadNode *T) {
    for (ThreadNode *p = Firstnode(T); p != NULL; p = Nextnode(p))
        visit(p); // 访问结点
}
ThreadNode *Firstnode(ThreadNode *p) {
    while (p->ltag == 0) p = p->lchild; //找到最左下结点
    return p;
}
ThreadNode *Nextnode(ThreadNode *p) {
    if (p->rtag == 0) return Firstnode(p->rchild);
    else return p->rchild; // 返回后继结点
}

对于中序线索二叉树的遍历，可以使用上述的实现方式，只需变化一些条件，具体可以练习。

对于先序和后序线索二叉树的遍历，类似的实现方式也可以使用。

树和森林

树的存储结构

双亲表示法

采用一组连续空间来存储每个结点，同时每个结点中增设一个伪指针，指示其双亲结点在数组中的位置。可以很快得到每个结点的双亲结点，但求结点的孩子时需要遍历整个结构。

存储结构描述:

#define MAX_TREE_SIZE 100 // 定义树的最大结点数
typedef struct {
    ElemType data; // 结点数据
    int parent; // 双亲结点的下标
} PTNode; // 双亲结点结构
typedef struct {
    PTNode nodes[MAX_TREE_SIZE]; // 存储结点的数组
    int n; // 结点数
} PTree; // 双亲表示法的树结构

双亲表示法表示一个森林：每棵树的根节点双亲指针= -1

孩子表示法

将每个结点的孩子结点都用单链表连接起来形成一个线性结构，n个结点就有n个孩子链表。寻找子女操作非常直接，而寻找双亲需要遍历n个结点中孩子链表指针域所指向的n个孩子链表

孩子表示法表示一个森林：用孩子表示法存储森林，需要记录多个根的位置

孩子兄弟表示法

又称二叉树表示法，即以二叉链表作为树的存储结构。每个结点分为三部分：结点值、指向结点第一个孩子节点的指针，指向结点下一个兄弟结点的指针。优点是可以方便地实现树转换为二叉树的操作，易于查找结点的孩子等。缺点是查找双亲麻烦

存储结构描述：

typedef struct CSNode {
    ElemType data; // 结点数据
    struct CSNode *firstchild; // 指向第一个孩子结点的指针
    struct CSNode *nextsibling; // 指向下一个兄弟结点的指针
} CSNode, *CSTree; // 孩子兄弟表示法

树、森林转化成二叉树

树转换为二叉树的规则：每个结点左指针指向它的第一个孩子结点，右指针指向它在树中相邻的兄弟节点，"左孩子右兄弟"，由树转换的二叉树没有右子树。

森林转换为二叉树：先将森林中的每棵树转换为二叉树，把第一棵树的根作为转换后二叉树的根，其左子树作为左子树。第二棵树作为转换后的右子树，第三棵树作为转换后右子树的右子树，即向右拼接。

二叉树转换为森林/树的规则：反过来即可。将右子树挨个拆下来。二叉树转换为树或森林是唯一的。

树和森林的遍历

树和森林遍历与二叉树遍历之前的对应关系

树	森林	二叉树
先根遍历	先序遍历	先序遍历
后根遍历	后序遍历	中序遍历

树与二叉树的应用

哈夫曼树和哈夫曼编码

结点的权 ：有某种现实含义的数值（如：表示结点的重要性等）

结点的带权路径长度 ：从树的根到该结点的路径长度（经过的边数）与该结点上权值的乘积

树的带权路径长度 ：树中所有叶结点的带权路径长度之和（WPL, Weighted Path Length）
W P L = ∑ i = 1 n w i ⋅ l i WPL=\sum_{i=1}^{n} w_i \cdot l_i WPL=i=1∑nwi⋅li

在含有n个带权叶节点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树（Huffman Tree），也称为最优二叉树。

例题：

由此算得：

W P L a = 7 ∗ 2 + 5 ∗ 2 + 2 ∗ 2 + 4 ∗ 2 = 36 WPL_a=7*2+5*2+2*2+4*2=36 WPLa=7∗2+5∗2+2∗2+4∗2=36
W P L b = 7 ∗ 3 + 5 ∗ 3 + 2 ∗ 1 + 4 ∗ 2 = 46 WPL_b=7*3+5*3+2*1+4*2=46 WPLb=7∗3+5∗3+2∗1+4∗2=46
W P L c = 7 ∗ 1 + 5 ∗ 2 + 2 ∗ 3 + 4 ∗ 3 = 35 WPL_c=7*1+5*2+2*3+4*3=35 WPLc=7∗1+5∗2+2∗3+4∗3=35(哈夫曼树)

构造方式：简单说，从结点中选出两个最小的结点，构成一个新节点，权为两结点之和，重复直到所有结点都处理完毕。

哈夫曼编码就是左0右1，那么a=0 ;b=10;c=110;d=111。

哈夫曼编码的特点是：没有一个编码是另一个编码的前缀，这样可以保证编码的唯一性。

并查集

并查集的概念及其实现

并查集是一种简单的集合表示，它支持以下操作：Initialize（初始化）、Find（查找）、Union（合并）。

并查集的存储结构

通常用树的双亲表示作为并查集的存储结构，每个子集合以一棵树表示。多说无益，直接看示意图：

假设有一个S={0,1,2,3,4,5,6,7,8,9,10}，初始化他们都是一个个的几个，每个子集合的数组值为-1。

初始表示：

经过系列计算以后，他们合并成为了三个集合： S 1 = { 0 , 6 , 7 , 8 } S_1=\{0,6,7,8\} S1={0,6,7,8}、 S 2 = { 1 , 4 , 9 } S_2=\{1,4,9\} S2={1,4,9}、 S 3 = { 2 , 3 , 5 } S_3=\{2,3,5\} S3={2,3,5}

又计算，想把 S 1 S_1 S1和 S 2 S_2 S2合并

结束，很一目了然的并查集

并查集操作的基本实现

#define MAX_SIZE 100 // 并查集的最大大小
int UFSets[MAX_SIZE];// 并查集数组（双亲表示法）
//初始化
void InitUFSets()
{
  for (int i = 0; i < MAX_SIZE; i++) UFSets[i] = -1; // 每个元素初始化为-1，表示每个元素都是一个独立的集合
}
//Find 找到集合的根元素
int Find(int x)
{
  while (UFSets[x] >= 0) x = UFSets[x];
  return x;
}
//Union 合并两个集合
void Union(int Root1, int Root2)
{
  if (Root1 != Root2) {//要求Root1和Root2是不同的集合
    UFSets[Root2] = Root1; // 将Root2的根元素指向Root1，表示合并
  }
}

注意：本代码并没有传递数组参数，因为只是一整个代码，已经放在全局变量中，遇到题目需要自行分析。

复杂度分析：Find操作的时间复杂度为 O ( d ) O(d) O(d)（d为树深度），Union操作的时间复杂度为O(1)。

并查集之优化

//改进后的Union
void Union(int Root1, int Root2) {
  if(Root1 != Root2) { //要求Root1和Root2是不同的集合
    if (UFSets[Root1] < UFSets[Root2]) { // Root1的集合更大
      UFSets[Root1] += UFSets[Root2]; // 更新Root1的大小
      UFSets[Root2] = Root1; // 将Root2的根元素指向Root1
    } else {
      UFSets[Root2] += UFSets[Root1]; // 更新Root2的大小
      UFSets[Root1] = Root2; // 将Root1的根元素指向Root2
    }
  }
}
//改进后的Find，目的在于压缩路径，只要是根的元素，就把他挂在根元素上。
int Find(int x) {
  int root = x;
  while(UFSets[root] >= 0) {
    root = UFSets[root]; // 找到根元素
  }
  while(x!=root){
    int temp = UFSets[x]; // 临时存储当前元素的父节点
    UFSets[x] = root; // 路径压缩，将当前元素直接指向根元素
    x = temp; // 移动到下一个元素
  }
  return root;
}