🔥 本文由程序喵正在路上原创，CSDN首发！
💖 系列专栏：数据结构与算法
🌠 首发时间：2022年11月7日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🌟 一以贯之的努力不得懈怠的人生

阅读指南

树的存储结构
- 双亲表示法（顺序存储）
- 孩子表示法（顺序+链式存储）
- 孩子兄弟表示法（链式存储）
- 森林和二叉树的转换
树和森林的遍历
- 树的先根遍历
- 树的后根遍历
- 树的层次遍历
- 森林的先序遍历
- 森林的中序遍历
二叉排序树
- 定义
- 二叉排序树的查找
- 二叉排序树的插入
- 二叉排序树的构造
- 二叉排序树的删除
- 查找效率分析
平衡二叉树
- 定义
- 平衡二叉树的插入
- 调整最小不平衡子树
- 查找效率分析
哈夫曼树
- 带权路径长度
- 哈夫曼树
- 哈夫曼树的构造
- 哈夫曼编码

树的存储结构

双亲表示法（顺序存储）

双亲表示法：每个结点中保存指向双亲的 “指针”，根节点固定存储在 $0$ ， $- 1$ 表示没有双亲

#define MAX_TREE_SIZE 100		//树中最多结点数

//树的结点定义
typedef struct{
	ElemType data;				//数据元素
	int parent;					//双亲位置域
}PTNode;

//树的类型定义
typedef struct{							
	PTNode nodes[MAX_TREE_SIZE];		//双亲表示
	int n;								//结点数
}PTree;

优点：查找指定结点的双亲很方便

缺点：查找指定结点的孩子只能从头遍历

孩子表示法（顺序+链式存储）

孩子表示法：顺序存储每个节点，每个结点中保存孩子链表头指针

struct CTNode{
	int child;				//孩子结点在数组中的位置
	struct CTNode *next;	//下一个孩子
};

typedef struct{
	ElemType data;
	struct CTNode *firstChild;		//第一个孩子
}CTBox;

typedef struct{
	CTBox nodes[MAX_TREE_SIZE];
	int n, r;		//结点数和根的位置
}CTree;

孩子兄弟表示法（链式存储）

//孩子兄弟表示法
typedef struct CSNode{
	ElemType data;								//数据域
	struct CSNode *firstchild, *nextsibling;	//第一个孩子和右兄弟指针
}CSNode, *CSTree;

森林和二叉树的转换

森林是 $(m\geq0)$ 棵互不相交的树的集合

在这里插入图片描述

本质：用二叉链表存储森林，左孩子右兄弟

树和森林的遍历

树的先根遍历

若树非空，先访问根结点，再依次对每棵子树进行先根遍历

//树的先根遍历
void PreOrder(TreeNode *R) {
	if (R) {
		visit(R);	//访问根结点
		while(R还有下一个子树T)
			PreOrder(T);	//先根遍历下一棵子树
	}
}

树的后根遍历

若树非空，先依次对每棵子树进行后根遍历，最后再访问根结点

//树的后根遍历
void PostOrder(TreeNode *R) {
	if (R) {
		while(R还有下一个子树T)
			PostOrder(T);	//后根遍历下一棵子树
		visit(R);	//访问根结点
	}
}

树的后根遍历与这棵树相应二叉树的中序序列相同

树的层次遍历

步骤：

若树非空，则根结点入队
若队列非空，队头元素出队并访问，同时将该元素的孩子依次入队
重复第 $2$ 步直到队列为空

树的层次遍历也可以称为广度优先遍历，树的先根和后根遍历也可以称为深度优先遍历

森林的先序遍历

森林是 $(m\geq0)$ 棵互不相交的树的集合。每棵树去掉根结点后，其各个子树又组成森林

若森林非空，则按照如下规则进行遍历：

访问森林中第一棵树的根结点
先序遍历第一个棵树中根结点的子树森林
先序遍历除去第一棵树之后剩余的树构成的森林

森林的先序遍历效果等同于依次对每个树进行先根遍历

如果我们先将森林转换为二叉树，那森林的先序遍历也等同于对应二叉树的先序遍历

森林的中序遍历

若森林非空，则按照如下规则进行遍历：

中序遍历第一个棵树中根结点的子树森林
访问森林中第一棵树的根结点
中序遍历除去第一棵树之后剩余的树构成的森林

森林的中序遍历效果等同于依次对每个树进行后根遍历

如果我们先将森林转换为二叉树，那森林的中序遍历也等同于对应二叉树的中序遍历

二叉排序树

定义

二叉排序树，又称为二叉查找树（ $BST$ ， $\ Search \;Tree$ ）

一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树：

左子树上所有结点的关键字均小于根结点的关键字
右子树上所有结点的关键字均大于根结点的关键字
左子树和右子树又各是一棵二叉排序树

我们可以发现，左子树结点值 < 根结点值 < 右子树结点值；同时，如果我们对一棵二叉排序树进行中序遍历，就可以得到一个递增的有序序列

二叉排序树的查找

若树非空，目标值与根结点的值比较：

如果相等，则查找成功
如果小于根结点，则在左子树上查找，否则在右子树上查找
查找成功，返回结点指针；查找失败则返回 $N ULL$

//二叉排序树结点
typedef struct BSTNode{
	int key;
	struct BSTNode *lchild, *rchild;
}BSTNode, *BSTree;

//在二叉排序树中查找值为 key 的结点
BSTNode *BST_Search(BSTree T, int key) {
	while (T && key != T->key) {	//若树空或等于根结点值，则结束循环
		if (key < T->key) T = T->lchild;	//小于，则在左子树上查找
		else T = T->rchild;					//大于，则在右子树上查找
	}
	return T;
}

非递归：最坏空间复杂度 $O (1)$

//在二叉排序树中查找值为 key 的结点（递归实现）
BSTNode *BST_Search(BSTree T, int key) {
	if (!T) return NULL;			//查找失败
	
	if (key == T->key) return T;	//查找成功
	else if (key < T->key) return BST_Search(T->lchild, key);	
	else return BST_Search(T->rchild, key);
}

递归：最坏空间复杂度 $O (h)$ ， $h$ 为树的高度

二叉排序树的插入

若原二叉排序树为空，则直接插入结点；否则，若关键字 $k$ 小于根结点值，则插入到左子树中；若关键字 $k$ 大于根结点值，则插入到右子树中

//在二叉排序树插入关键字为 k 的新结点（递归实现）
int BST_Insert(BSTree &T, int k) {
	if (!T) {		//原树为空
		T = (BSTree)malloc(sizeof(BSTNode));
		T->key = k;
		T->lchild = T->rchild = NULL;
		return 1;				//返回 1, 插入成功
	} else if (k == T->key) {	//树中存在相同关键字的结点, 插入失败
		return 0;
	} else if (k < T->key) {	//小于, 插入到左子树
		return BST_Insert(T->lchild, k);
	} else {					//大于, 插入到右子树
		return BST_Insert(T->rchild, k);
	}
}

最坏空间复杂度为 $O (h)$

二叉排序树的构造

//按照 str[] 中的关键字序列建立二叉排序树
void Creat_BST(BSTree &T, int str[], int n) {
	T = NULL;		//初始时为空树
	int i = 0;
	while (i < n) {		//依次将每个关键字插入到二叉排序树中
		BST_Insert(T, str[i]);
		++i;
	}
}

不同的关键字序列可能得到同款二叉排序树，也可能得到不同款二叉排序树

二叉排序树的删除

先搜索找到目标结点：

如果被删除结点 $z$ 是叶子结点，则直接删除，不会破坏二叉排序树的性质
如果被删除结点 $z$ 只有一棵左子树或右子树，则让 $z$ 的子树成为 $z$ 父结点的子树，替代 $z$ 的位置
如果 $z$ 有左、右两颗子树，则令 $z$ 的直接后继（或直接前驱）替代 $z$ ，然后从二叉排序树中删去这个直接后继（或直接前驱），这样就转换成了第一或第二种情况

第 $3$ 种情况中的直接后继和直接前驱也就是 $z$ 的中序后继和中序前驱， $z$ 的后继为 $z$ 的右子树中最左下的结点（该结点一定没有左子树）， $z$ 的前驱为 $z$ 的左子树中最右下的结点（该结点一定没有右子树）

查找效率分析

查找长度 —— 在查找运算中，需要对比关键字的次数称之为查找长度，反映了查找操作的时间复杂度

若树高 $h$ ，找到最下层的一个结点需要对比 $h$ 次

最好情况： $n$ 个结点的二叉树最小高度为 $\lfloor log_2{n} + 1 \rfloor$ ，平均查找长度为 $O(log_2{n})$

最坏情况：每个结点只有一个分支，树高 $h$ 等于结点数 $n$ ，平均查找长度为 $O (n)$

查找成功的平均查找长度 $A S L$ （ $\ Search \ Length$ ) 计算方式例子：

在这里插入图片描述

也就是（ [ 每层结点数乘以每层结点查找长度 ] 之和）/ 总结点数

查找失败的平均查找长度 $A S L$ （ $\ Search \ Length$ ) 计算方式：

平衡二叉树

定义

平衡二叉树（ $\ Binary \ Tree$ )，简称平衡树（ $A V L$ 树）—— 树上任一结点的左子树和右子树的高度之差不超过 $1$

结点的平衡因子 $=$ 左子树高 $-$ 右子树高，平衡二叉树结点的平衡因子的值只可能是 $- 1 、 0$ 或者 $1$ ，只要有任一结点的平衡因子的绝对值大于 $1$ ，就不是平衡二叉树

//平衡二叉树结点
typedef struct AVLNode{
	int key; 		//数据域
	int balance;	//平衡因子
	struct AVLNode *lchild, *rchild;
}AVLNode, *AVLTree;

平衡二叉树的插入

在二叉排序树中插入新结点后，该如何保持平衡？

查找路径上的所有结点都有可能受到影响，所以我们从插入点往回找到第一个不平衡的结点，调整以该结点为根的子树，每次调整的对象都是 “最小不平衡子树”

在插入操作中，我们只需要将最小不平衡子树调整平衡，则其他祖先结点都会恢复平衡

调整最小不平衡子树

$LL$ ：在 $A$ 的左孩子的左子树中插入导致不平衡
$RR$ ：在 $A$ 的右孩子的右子树中插入导致不平衡
$L R$ ：在 $A$ 的左孩子的右子树中插入导致不平衡
$R L$ ：在 $A$ 的右孩子的左子树中插入导致不平衡

调整最小不平衡子树 —— LL：

假设最小不平衡子树如下图：

在这里插入图片描述

$LL$ 平衡旋转（右单旋转）。由于在结点 $A$ 的左孩子（ $L$ ）的左子树（ $L$ ）上插入了新结点， $A$ 的平衡因子由 $1$ 增至 $2$ ，导致以 $A$ 为根的子树失去平衡，需要一次向右的旋转操作。将 $A$ 的左孩子 $B$ 向右上旋转代替 $A$ 成为根结点，将 $A$ 结点向右下旋转成为 $B$ 的右子树的根结点，而 $B$ 的原右子树则作为 $A$ 结点的左子树

调整最小不平衡子树 —— RR：

$RR$ 平衡旋转（右单旋转）。由于在结点 $A$ 的右孩子（ $R$ ）的右子树（ $R$ ）上插入了新结点， $A$ 的平衡因子由 $- 1$ 增至 $- 2$ ，导致以 $A$ 为根的子树失去平衡，需要一次向左的旋转操作。将 $A$ 的右孩子 $B$ 向左上旋转代替 $A$ 成为根结点，将 $A$ 结点向左下旋转成为 $B$ 的左子树的根结点，而 $B$ 的原左子树则作为 $A$ 结点的右子树

右旋和左旋代码思路：

右旋：假设指针 $f$ 指向最小不平衡子树的根， $p$ 指向根的左子树，那么 $f$ 向右下旋转， $p$ 向右上旋转，其中 $f$ 是爹， $p$ 为左孩子， $g f$ 为 $f$ 的爹

在这里插入图片描述

f->lchild = p->rchild;	
p->rchild = f;
gf->lchild/rchild = p;

左旋：假设指针 $f$ 指向最小不平衡子树的根， $p$ 指向根的右子树，那么 $f$ 向左下旋转， $p$ 向左上旋转，其中 $f$ 是爹， $p$ 为左孩子， $g f$ 为 $f$ 的爹

在这里插入图片描述

f->rchild = p->lchild;	
p->lchild = f;
gf->lchild/rchild = p;

调整最小不平衡子树 —— LR：

在这里插入图片描述

$L R$ 平衡旋转（先左后右双旋转）。由于在结点 $A$ 的左孩子（ $L$ ）的右子树（ $R$ ）上插入了新结点， $A$ 的平衡因子由 $1$ 增至 $2$ ，导致以 $A$ 为根的子树失去平衡，需要进行两次旋转操作，先左旋转后再右旋转。先将 $A$ 的左孩子 $B$ 的右子树的根结点 $C$ 向左上旋转提升到 $B$ 结点的位置，然后再把该 $C$ 结点向右上旋转提升到 $A$ 结点的位置

调整最小不平衡子树 —— RL：

在这里插入图片描述

$R L$ 平衡旋转（先右后左双旋转）。由于在结点 $A$ 的右孩子（ $R$ ）的左子树（ $L$ ）上插入了新结点， $A$ 的平衡因子由 $- 1$ 增至 $- 2$ ，导致以 $A$ 为根的子树失去平衡，需要进行两次旋转操作，先右旋转后再左旋转。先将 $A$ 的右孩子 $B$ 的左子树的根结点 $C$ 向右上旋转提升到 $B$ 结点的位置，然后再把该 $C$ 结点向左上旋转提升到 $A$ 结点的位置