数据结构第三部分：树与树的表示、二叉树及其遍历、二叉搜索树、平衡二叉树、堆、哈夫曼树、集合及其运算

参考：浙大数据结构(陈越、何钦铭)课件

1、树与树的表示

什么是树？

客观世界中许多事物存在层次关系

• 人类社会家谱
• 社会组织结构
• 图书信息管理

分层次组织在管理上具有更高的效率！

数据管理的基本操作之一：查找（根据某个给定关键字K，从集合R 中找出关键字与K 相同的记录）。一个自然的问题就是，如何实现有效率的查找？

• 静态查找：集合中记录是固定的，没有插入和删除操作，只有查找
• 动态查找：集合中记录是动态变化的，除查找，还可能发生插入和删除

静态查找——方法一：顺序查找（时间复杂度O(n)）

int SequentialSearch(StaticTable * Tbl, ElementType K)
{
	// 在表Tbl[1]~Tbl[n] 中查找关键字为K的数据元素
	int i;
	Tabl->Element[0] = K; // 建立哨兵
	for(i = Tbl->Length; Tbl->Element[i] != K; i--)
		;
	return i; // 查找成功返回所在单元下标；不成功返回0
}

静态查找——方法二：二分查找（时间复杂度O(logn)）

二分查找的启示？

　　二分查找判定树：

• 判定树上每个结点需要的查找次数刚好为该结点所在的层数
• 查找成功时查找次数不会超过判定树的深度
• n 个结点的判定树的深度为⌊log₂n⌋+1

树的定义

树（Tree）：n（n ≥ 0）个结点构成的有限集合。

　　当n = 0 时，称为空树。

　　对于任一颗非空树（n > 0），它具备以下性质：

• 树中有一个称为"根（Root）"的特殊结点，用r 表示；
• 其余结点（与r 相关联的）可分为m（m  > 0）个互不相交的有限集T₁，T₂，...，T_m，其中每个集合本身又是一颗树，称为原来树的"子树（SubTree）"。

树与非树？

• 子树是不相交的
• 除了根结点外，每个结点有且仅有一个父节点
• 一颗N个结点的树有N-1条边（我认为可以用构造性的存在性证明或是数学归纳法来证明这一点）

树的一些基本术语：

• 结点的度（Degree）：结点的子树个数
• 树的度：树的所有结点中最大的度数
• 叶结点（Leaf）：度为0的结点
• 父结点（Parent）：有子树的结点是其子树的根结点的父结点
• 子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点
• 兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点
• 路径和路径长度：从结点n₁到n_k的路径为一个结点序列n₁，n₂，...，n_k，n_i是n_i+1的父结点，路径所包含的边的个数为路径的长度
• 祖先结点（Ancestor）：沿树根到某一结点路径上的所有结点都是这个结点的祖先结点
• 子孙结点（Descendant）：某一结点的子树中的所有结点都是这个结点子孙
• 结点的层次（Level）：规定根结点在1层，其它任一结点的层数时其父节点的层数加1
• 树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度

 树的表示

为可节省空间，最常用的表示树的方法是儿子-兄弟表示法。

 2、二叉树及存储结构

二叉树的定义

二叉树T：一个有穷的结点集合

　　这个集合可以为空

　　若不为空，则它是由根结点和称为其左子树T_L和右子树T_R的两个不相交的二叉树组成

• 二叉树具有五种基本形态（空、单根、根+T_L、根+T_R、根+T_L+T_R）
• 二叉树的子树有左右顺序之分

特殊二叉树

　　斜二叉树（Skewed Binary Tree）、完美二叉树（Perfect Binary Tree）/满二叉树（Full Binary Tree）、完全二叉树（Complete Binary Tree）

　　这里重点介绍下CBT：有n 个结点的二叉树，对树中结点按从上至下、从左至右顺序进行编号，编号为i （1 ≤ i ≤ n）结点与满二叉树中编号为i 结点在二叉树中位置相同

二叉树几个重要性质

• 一个二叉树第i 层的最大结点数为：2^i-1，i ≥ 1
• 深度为k 的二叉树有最大结点总数为：2^k-1，k ≥ 1
• 对任何非空二叉树T，若n₀ 表示叶结点的个数，n₂ 是度为2 的非叶结点个数，那么两者满足关系n₀ = n₂ + 1（证明见这里）

二叉树的抽象数据类型

重要操作：

• BinTree CreateBinTree()：创建一个二叉树
• Boolean IsEmpty(BinTree BT)：判别BT 是否为空
• void Traversal(BinTree BT)：遍历，按某顺序访问每个结点

常用的遍历方法有：

• void PreOrderTraversal(BinTree BT)：先序——根、左子树、右子树
• void InOrderTraversal(BinTree BT)：中序——左子树、根、右子树
• void PostOrderTraversal(BinTree BT)：后序——左子树、右子树、根
• void LevelOrderTraversal(BinTree BT)：层次遍历——从上到下、从左到右

二叉树的存储结构

顺序存储结构

　　依完全二叉树的形式存储：按从上到下、从左到右顺序存储。

　　n 个结点的完全二叉树的节点父子关系：

• 非根节点（序号i > 1）的父结点序号是⌊i/2⌋
• 结点（序号为i）的左孩子结点的序号是2i（若2i ≤ n，否则没有左孩子）
• 结点（序号为i）的右孩子结点的序号是2i+1（若 2i+1 ≤ n，否则没有右孩子）

　　应当注意的一点是：一般二叉树也可以采用这种结构，但会造成空间浪费

链表存储

typedef struct TreeNode *BinTree;
typedef BinTree Position;
struct TreeNode{
	ElementType Data;
	BinTree Left;
	BinTree Right;
}

3、二叉树的遍历

二叉树的递归遍历

先序遍历：访问根结点；先序遍历其左子树；先序遍历其右子树

void PreOrderTraversal(BinTree BT)
{
	if(BT)
	{
		printf("%d", BT->data);
		PreOrderTraversal(BT->Left);
		PreOrderTraversal(BT->Right);
	}
}

中序遍历：中序遍历其左子树；访问根结点；中序遍历其右子树

void InOrderTraversal(BinTree BT)
{
	if(BT)
	{
		InOrderTraversal(BT->Left);
		printf("%d", BT->Data);
		InOrderTraversal(BT->Right);
	}
}

后序遍历：后续遍历其左子树；后续遍历其右子树；访问根结点

void PostOrderTraversal(BinTree BT)
{
	if(BT)
	{
		PostOrderTraversal(BT->Left);
		PostOrderTraversal(BT->Right);
		printf("%d", BT->Data);
	}
}

附注：先序、中序和后序遍历过程：遍历过程经过结点的路线一样，只是访问各结点的时机不同。下图在从入口到出口的曲线上用ⓧ、★和△三种符号分别标记出了先序、中序和后序访问各结点的时刻

先序：当曲线第一次经过一个结点时，就列出这个结点；中序：当曲线第一次经过一个树叶时，就列出这个树叶，当曲线第二次经过一个内点时就列出这个内点；后序：当曲线最后一次经过一个结点而返回这个结点的父亲时，就列出这个结点。

二叉树的非递归遍历

非递归遍历算法实现的基本思路：使用堆栈。我们以中序遍历的非递归算法为例：

• 遇到一个结点，就把它压栈，并去遍历它的左子树
• 当左子树遍历结束后，从栈顶弹出这个结点并访问它
• 然后按其右指针再去中序遍历该结点的右子树

void InOrderTraversal(BinTree BT)
{
	BinTree T = BT;
	Stack S = CreateStack(MaxSize); // 创建并初始化堆栈
	while(T || !IsEmpty(S))
	{
		while(T) // 一直向左并将沿途结点压入堆栈
		{
			Push(S, T);
			T = T->Left;
		}
		if(!IsEmpty(S)) // 不是必须的，因为while入口处已经判断过了
		{
			T = Pop(S); // 结点弹出堆栈
			printf("%5d", T->Data); // (访问)打印结点
			T = T->Right; // 转向右子树
		}
	}
}

注意到先序的非递归算法只要在中序非递归算法的基础上做一下调整就好了：printf语句放到Push操作之前。而后续遍历就比较繁琐了，因为当指针T指向一个结点时，不能马上对它进行访问，而要先遍历它的左子树，因而要将此结点的地址进栈保存。当其左子树遍历完毕之后，再次搜索到该结点时（退栈），还不能对它访问，还需要遍历它的右子树，所以，再一次将此结点的地址进栈保存。为了区别同一结点的两次进栈，需要引入一个标志变量，比如flag为0表示该结点暂不访问，为1表示该结点可以访问。

层序遍历

层序遍历基本过程：先根结点入队，然后：

• 从队列中取出一个元素
• 访问该元素所指结点
• 若该结点所指结点的左、右孩子结点非空，则将其左、右孩子的指针顺序入队

void LevelOrderTraversal(BinTree BT)
{
	Queue Q;
	BinTree T;
	if(!BT) // 若是空树直接返回
		return; 
	Q = CreateQueue(MaxSize); // 创建并初始化队列Q
	AddQ(Q, BT);
	while(!IsEmpty(Q))
	{
		T = Delete(Q);
		printf("%d\n", T->Data); // 访问取出队列的结点
		if(T->Left)
			AddQ(Q, T->Left);
		if(T->Right)
			AddQ(Q, T->Right);
	}
}

遍历二叉树的应用

输出二叉树中的叶子结点

　　在二叉树的遍历算法中增加检测结点的"左右子树是否都为空"

void PreOrderPrintLeaves(BinTree BT)
{
	if(BT)
	{
		if(!BT->Left && !BT->Right)
			printf("%d", BT->Data);
		PerOrderPrintLeaves(BT->Left);
		PerOrderPrintLeaves(BT->Right);
	}
}

求二叉树的高度

　　需要注意到Height = Max(H_L, H_R) + 1

int PostOrderGetHeight(BinTree BT)
{
	int HL, HR, MaxH;
	if(BT)
	{
		HL = PostOrderGetHeight(BT->Left); // 求左子树的深度
		HR = PostOrderGetHeight(BT->Right); // 求右子树的深度
		MaxH = (HL > HR) ? HL : HR; // 取左右子树中较大的深度
		return MaxH + 1; // 返回树的深度
	}
	else
		return 0; // 空树深度为0
}

由先序和中序遍历序列来确定一颗二叉树

• 根据先序遍历序列第一个结点确定根结点
• 根据根结点在中序遍历序列中的位置分隔出左右两个子序列
• 对左子树和右子树分别递归使用相同的方法继续分解

　　类似地，后序和中序遍历序列也可以确定一颗二叉树

4、二叉搜索树

先来回顾一下之前提到的查找问题（静态查找与动态查找），针对动态查找，数据如何组织？

什么是二叉搜索树

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树：一颗二叉树，可以为空；如果不为空，满足以下性质：

• 非空左子树的所有键值小于其根结点的键值
• 非空右子树的所有键值大于其根结点的键值
• 左、右子树都是二叉搜索树

二叉搜索树操作的特别函数

• Postion Find(ElementType X, BinTree BST)：从二叉搜索树BST中查找元素X，返回其所在结点的地址
• Postion FindMin(BinTree BST)：从二叉搜索树BST中查找并返回最小元素所在结点的地址
• Position FindMax(BinTree BST)：从二叉搜索树BST中查找并返回最大元素所在结点的地址
• BinTree Insert(ElementType X, BinTree BST)
• BinTree Delete(ElementType X, BinTree BST)

二叉搜索树的查找操作：Find

• 查找从根结点开始，如果树为空，返回NULL
• 若搜索树非空，则根结点关键字和X进行比较，并进行不同处理：

　　　　　　若X小于根结点键值，只需在左子树中继续搜索

　　　　　　若X大于根结点的键值，在右子树中继续进行搜索

　　　　　　若两者比较结果相等，搜索完成，返回指向此结点的指针。

Positon Find(ElementType X, BinTree BST)
{
	if(!BST)
		return NULL; // 查找失败
	if(X > BST->Data)
		return Find(X, BST->Right); // 在右子树中继续查找
	else if
		return Find(X, BST->Left); // 在左子树中继续查找
	else // X == BST->Data
		return BST; // 查找成功，返回结点的地址
}

上面程序中的两处递归调用都是尾递归，因此可以方便的改写为迭代函数，以便提高执行效率（注意到，查找的效率取决于树的高度）

Position IterFind(ElementType X, BinTree BST)
{
	while(BST)
	{
		if(X > BST->Data)
			BST = BST->Right; // 向右子树中移动，继续查找
		else if(X < BST->Data)
			BST = BST->Left; // 向左子树中移动，继续查找
		else // X == BST->Data
			return BST; // 查找成功，返回结点的地址
	}
	return NULL; // 查找失败
}

查找最大和最小元素

　　只需注意到以下事实：

• 最大元素一定在树的最右分支的端结点上
• 最小元素一定在树的最左分支的端节点上

查找最小元素的递归函数

Postion FindMin(BinTree BST)
{
	if(!BST)
		return NULL; // 空的二叉搜索树，返回NULL
	else if(!BST->Left)
		return BST; // 找到最左叶结点并返回
	else 
		return FindMin(BST->Left); // 沿左分支继续查找
}

查找最大元素的迭代函数

Position FindMax(BinTree BST)
{
	if(BST)
		while(BST->Right)
			BST = BST->Right; // 沿右分支继续查找，直到最右结点
	return BST;
}

二叉搜索树的插入

　　关键是要找到元素应该插入的位置，可以采用与Find类似的方法

BinTree Insert(ElementType X, BinTree BST)
{
	if(!BST)
	{
		// 若原树为空，生成并返回一个结点的二叉搜索树
		BST = malloc(sizeof(struct TreeNode));
		BST->Data = X;
		BST->Left = BST->Right = NULL;
	}
	else // 开始找要插入元素的位置
	{
		if(X < BST->Data)
			BST->Left = Insert(X, BST->Left); // 递归插入左子树
		else if(X > BST->Data)
			BST->Right = Insert(X, BST->Right); // 递归插入右子树
		// else X已经存在，什么都不做
	}
	return BST;
}

关于上面的代码，多说一点，就是关于递归调用返回的时候需要赋值给左子树或右子树，这在大多数赋值的情况下显得多余（就像是说，把当前树的左子树赋值给它的左子树），但是它是必须的，因为在插入元素的时候我们需要知道它的父结点的左指针或右指针。我们也可以消除不必要的赋值，但是它是以增加逻辑判断为代价的，还不如原先的方式显得清晰、美观。

二叉搜索树的删除

　　要考虑三种情况

• 要删除的是叶节点：直接删除，并再修改其父结点指针，置为NULL
• 要删除的结点只有一个孩子结点：将其父结点的指针指向要删除结点的孩子结点
• 要删除的结点有左、右两颗子树：用另一结点替代被删除结点：右子树的最小元素或者左子树的最大元素

BinTree Delete(ElementType X, BinTree BST)
{
	Position Tmp;
	if(!BST)
		printf("要删除的元素未找到");
	else if(X < BST->Data)
		BST->Left = Delete(X, BST->Left); // 左子树递归删除
	else if(X > BST->Data)
		BST->Right = Delete(X, BST->Right); // 右子树递归删除
	else // 找到要删除的结点
	{
		if(BST->Left && BST->Right) // 被删除结点有左右两个子结点
		{
			Tmp = FindMin(BST->Right); // 在右子树中找最小的元素填充删除结点
			BST->Data = Tmp->Data;
			BST->Right = Delete(BST->Data, BST->Right); // 在删除结点的右子树中删除最小元素
		}
		else // 被删除结点有一个或无子结点
		{
			Tmp = BST;
			if(!BST->Left) // 有右孩子或无子结点
				BST = BST->Right;
			else if(!BST->Right) // 有左孩子或无子结点
				BST = BST->Left;
			free(Tmp);
		}
	}
	return BST;
}

 5、平衡二叉树

什么是平衡二叉树

搜索树结点不同插入次序，将导致不同的深度和平均查找程度，这促使二叉树"平衡"这个概念的出现。二叉树平衡与否的度量由"平衡因子"（Balance Factor，简称BF：BF(T) = H_L - H_R，其中H_L和H_R分别为T的左、右子树的高度）来决定。

平衡二叉树（Balanced Binary Tree）（AVL树）：

　　空树，或者任一结点左、右子树高度差的绝对值不超过1，即|BF(T)| ≤ 1

我们之所以想要二叉树在一定程度上达到平衡，就是奔着它的效率去的，那么很自然的一个问题是：平衡二叉树的高度能达到log₂n吗？

设n_h 为高度为h 的平衡二叉树的最少结点数。结点数最少时：n_h = n_h-1 + n_h-2 + 1。

可以看到，其形式非常类似于斐波那契数列。我们结合初始条件n₀ = 1，n₁ = 2不难得出n_h = F_h+2 - 1。于是我们可以说h = O(log₂n)。通俗的说就是，给定结点数为n 的AVL树的最大高度为O(log₂n)。

平衡二叉树的调整

AVL树的调整分为四种情况，分别为左单旋、右单旋、左右双旋、右左双旋。值得注意的一点是：有时候插入元素即便不需要调整结构，也可能需要重新计算一些平衡因子。

何老师给的图很好，简洁明了的表达了需要调整的情况并且给出了具体调整的方法：

下面是程序实现：

typedef struct AVLTreeNode *AVLTree;
typedef struct AVLTreeNode{
	ElementType Data;
	AVLTree Left;
	AVLTree Right;
	int Height;
};

AVLTree AVL_Insertion(ELementType X, AVLTree T)
{
	// 将X插入AVL树中，并且返回调整后的AVL树
	if(!T) // 若插入空树，则新建一个包含一个结点的树
	{
		T = (AVLTree) malloc(sizeof(struct AVLTreeNode));
		T->Data = X;
		T->Height = 0;
		T->Left = T->Right = NULL;
	} // if(插入空树)结束
	else if(X < T->Data) // 插入T的左子树
	{
		T->Left = AVL_Insertion(X, T->Left);
		if(GetHeight(T->Left) - GetHeight(T->Right) == 2)
		{
			// 需要左旋
			if(X < T->Left->Data)
				T = SingleLeftRotation(T); // 左单旋
			else
				T = DoubleLeftRightRotation(T); // 左-右双旋
		}
	} // else if(插入左子树)结束
	else if(X > T->Data) // 插入T的右子树
	{
		T->Right = AVL_Insertion(X, T->Right);
		if(GetHeight(T->Left) - GetHeight(T->Right) == -2)
		{
			// 需要右旋
			if(X > T->Right->Data)
				T = SingleRightRotation(T); // 右单旋
			else
				T = DoubleRightLeftRotation(T); // 右-左双旋
		}
	} //else if(插入右子树)结束
	
	// else X == T->Data, 无须插入
	
	T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1; // 更新树高
	
	return T; 
}

AVLTree SingleLeftRotation(AVLTree A)
{
	// 注意：A必须有一个左子结点B
	// 将A与B做如图所示的左单旋，更新A与B的高度，返回新的根结点B
	AVLTree B = A->Left;
	A->Left = B->Right;
	B->Right = A;
	A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
	B->Height = Max(GetHeight(B->Left), A->Height) + 1;
	
	return B;
}

AVLTree DoubleLeftRightRotation(AVLTree A)
{
	// 注意：A必须有一个左子结点B，且B必须有一个右子结点C
	// 将A、B与C做如图所示的两次单旋，返回新的根结点C
	A->Left = SingleRightRotation(A->Left); // 将B与C做右单旋，C被返回
	
	return SingleLeftRotationO(A); // 将A与C做左单旋，C被返回
}

6、堆　

什么是堆

　　优先队列（Priority Queue）：特殊的"队列"，取出元素的顺序是依照元素的优先权（关键字）的大小，而不是元素进入队列的先后顺序。

　　问题：如何组织优先队列？

• 一般的数组、链表？
• 有序的数组、链表？
• 二叉搜索树？AVL树？

　　对于堆来说，主要就是两个操作，插入和删除，而无论是一般的数组、链表，还是有序的数组、链表其中至少有一个操作是需要O(n) 的时间来完成的。可以考虑能否采用二叉树存储结构？如果采用这种存储结构的话，我们更应该关注插入还是删除操作？树结点顺序怎么安排？树结构怎样？

　　堆的两个特性：

• 结构性：用数组表示的完全二叉树
• 有序性：任一结点的关键字是其子树所有结点的最大值（或最小值）

堆的抽象数据类型

以最大堆为例，其主要操作有：

• MaxHeap Create(int MaxSize)：创建一个空的最大堆
• Boolean IsFull(MaxHeap H)：判断最大堆H是否已满
• void Insert(MaxHeap H, ElementType item)：将元素item插入最大堆H
• Boolean IsEmpty(MaxHeap H)：判断最大堆是否为空
• ElementType DeleteMax(MaxHeap H)：返回H中最大元素（高优先级）

 最大堆的创建

typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
	ElementType *Elements; // 存储堆元素的数组
	int Size; // 堆的当前元素个数
	int Capacity; // 堆的最大容量
}

MaxHeap Create(int MaxSize)
{
	// 创建容量为MaxSize的空的最大堆
	MaxHeap H = malloc(sizeof(struct HeapStruct));
	H->Elements = malloc((MaxSize+1) * sizeof(ElementType));
	H->Size = 0;
	H->Capacity = MaxSize;
	H->Elements[0] = MaxData; // 定义"哨兵"为大于堆中所有可能元素的值，便于以后更快操作
	return H;
}

注意到，把MaxData换成小于堆中所有元素的MinData，同样适用于创建最小堆。

最大堆的插入

　　思路：首先默认插入位置在完全二叉树的下一个位置，通过向下过滤结点的方式，从其父结点到根结点的有序序列中寻找合适的位置进行插入操作

void Insert(MaxHeap H, ElementType item)
{
	// 将元素item插入最大堆H，其中H->Elements[0]已经定义为哨兵
	int i;
	if(IsFull(H))
	{
		printf("最大堆已满");
		return;
	}
	i = ++H->Size; // i指向插入后堆中的最后一个元素的位置
	for(; H->Elements[i/2] < item; i /= 2)
		H->Elements[i] = H->Elements[i/2]; // 向下过滤结点，这种方式比交换数据来得快
	H->Elements[i] = item; // 将item插入
}

上述代码中，H->Elements[0]是哨兵元素，它不小于堆中的最大元素，控制循环结束。时间复杂度O(logN)。

最大堆的删除

　　思路：取出根结点（最大值），同时删除它，方法就是用堆中的最后一个元素代替之（和插入操作一样，这里的代替只是形式上方便理解的说辞，实际上我们只是用一个临时变量保存其值而已，这比真实的替代更省时），但是其位置不一定正确，因此需要从根结点开始向上过滤下层结点。

ElementType DeleteMax(MaxHeap H)
{
	// 从最大堆H中取出键值为最大的元素，并删除一个结点
	int Parent, Child;
	ElementType MaxItem, temp;
	if(IsEmpty(H))
	{
		printf("最大堆已为空");
		return;
	}
	MaxItem = H->Elements[1]; // 取出根结点最大值
	// 用最大堆中最后一个元素从根结点开始向上过滤下层结点
	temp = H->Elements[H->Size--];
	for(Parent = 1; Parent*2 <= H->Size; Parent = Child)
	{
		Child = Parent*2;
		if((Child != H->Size) && (H->Elements[Child] < H->Elements[Child+1]))
			Child++; // Child指向左右子结点中的较大者
		if(temp >= H->Elements[Child])
			break;
		else // 移动temp元素到下一层
			H->Elements[Parent] = H->Elements[Child];
	}
	H->Elements[Parent] = temp;
	return MaxItem;
}

最大堆的建立

　　建立最大堆：将已经存在的N个元素按最大堆的要求存放在一个一维数组中

• 方法一：通过插入操作，将N个元素一个个相继插入到一个初始为空的堆中去，其时间代价为O(NlogN)
• 方法二：线性时间复杂度下建立最大堆
• 将N个元素按输入顺序存入，先满足完全二叉树的结构特性
• 调整各结点位置，以满足最大堆的有序特性。

重点说下方法二，从完全二叉树的倒数第二层开始调整，因为其左、右子树只有一个结点，本身构成了一个堆，因此可以用过滤的方式以当前层为根，将根放到合适的位置。经过一轮调整，可以从倒数第三层开始（其左、右子树仍然各自构成一个堆），续行此法，直到完全二叉树的Root放置到合适的位置为止。

可以证明（由每层的结点数和该层的最多交换次数找出一般规律，利用错位相消可解出闭形式）这种方法的时间复杂度是线性的，即T(N) = O(N)。

7、哈夫曼树与哈夫曼编码

什么是哈夫曼树

我们需要先引入一个概念——带权路径长度（WPL）：

　　设二叉树有n个叶子结点，每个叶子结点带有权值W_k，从根结点到每个叶子结点的长度为L_k，则每个叶子结点的带权路径长度之和就是WPL = Σ_(k=1~n)W_kL_k

最优二叉树或哈夫曼树就是WPL最小的二叉树，因此哈夫曼树说白了就是根据结点不同的查找频率构造的最有效的搜索树。

哈夫曼树的构造

　　基本思路：每次把权值最小的两颗二叉树合并，把两者的和作为当前树新的权值，再取两个权值最小的二叉树合并，续行此法，直至结点取空。

下面是时间复杂度为O(NlogN)的做法：

typedef struct TreeNode *HuffmanTree;
struct TreeNode{
	int Weight;
	HuffmanTree Left, Right;
}
HuffmanTree Huffman(MinHeap H)
{
	// 假设H->Size个权值已经存在H->Elements[]->Weight里
	int i;
	HuffmanTree T;
	BuildMinHeap(H); // 将H->Elements[]按权值调整为最小堆
	for(i = 1; i < H->Size; i++) // 做H->Size-1次合并
	{
		T = malloc(sizeof(struct TreeNode)); // 建立新结点
		T->Left = DeleteMin(H); // 从最小堆中删除一个结点，作为新T的左子结点
		T->Right = DeleteMin(H); // 从最小堆中删除一个结点，作为新T的右子结点
		T->Weight = T->Left->Weight + T->Right->Weight; // 计算新权值
		Insert(H, T); // 将新T值插入最小堆
	}
	T = DeleteMin(H);
	return T; 
}

哈夫曼树的特点

• 没有度为1的结点
• n个叶子结点的哈夫曼树共有2n-1个结点
• 哈夫曼树的任意非叶结点的左右子树交换后仍是哈夫曼树
• 对同一组权值{W₁，W₂，...，W_n}，是否存在不同构的两颗哈夫曼树呢？

　　答案是肯定的，比如对于一组权值{1，2，3，3}，不同构的两颗哈夫曼树如下：

容易算出二者的WPL值均为18，之所以出现这样的结果是因为3个权值为3的结点合并的时机不同导致的。

哈夫曼编码

考虑这样一个问题：用位串来编码英语字母表里的字母（不区分大小写），可以用长度为5的位串来表示每个字母，这样用来编码数据的总数是5乘以文本中的字符数，有没有可能找出这些字母的编码方案，使得在编码数据时使用的位更少？若可能，那么就可以节省存储空间。

哈夫曼编码作为一种不等长的编码形式，一个需要解决的关键性问题就是如何避免二义性。为了保证无二义地解码，我们采用前缀码——任何字符的编码都不是另一个字符编码的前缀。用二叉树进行编码：左右分支0、1；字符只在叶节点上。

8、集合及运算

集合的表示

• 集合运算：交、并、补、差，判定一个元素是否属于某一集合
• 并查集：集合并、查某元素属于什么集合
• 并查集问题中集合存储如何实现？可以用树结构表示集合，树的每个结点代表一个集合元素，采用双亲表示法：孩子指向父结点。

更加简便的方法是采用数组存储形式，数组中有两个域：Data和Parent。其中Parent为负数表示根结点，非负数表示双亲结点的下标。数组中每个元素的类型描述如下：

typedef struct{
	ElementType Data;
	int Parent;
}SetType;

集合运算

查找某个元素所在的集合（用根结点表示）

int Find(SetType S[], ElementType X)
{
	// 在数组中查找值为X的元素所属的集合
	// MaxSize是全局变量，为数组S的最大长度
	int i;
	for(i = 0; i < MaxSize && S[i].Data != X; i++)
		;
	if(i >= MaxSize)
		return -1; // 未找到X，返回-1
	for(; S[i].Parent >= 0; i = S[i].Parent)
		;
	return i; // 找到X所属集合，返回数根结点在数组S中的下标
}

集合的并运算

• 分别找到X1和X2两个元素所在集合树的根结点
• 如果它们不同根，则将其中一个根结点的父结点指针设置成另一个根结点的数组下标

void Union(SetType S[], ElementType X1, ElementType X2)
{
	int Root1, Root2;
	Root1 = Find(S, X1);
	Root2 = Find(S, X2);
	if(Root1 != Root2)
		S[Root2].Parent = Root1;
}

效率优化

注意到上面的Union操作可能导致的一个问题就是树倾斜问题严重，导致Find操作低效，因此一个自然的想法，就是把小的集合合并到大的集合中，为此可以为数据结构增加一个域代表该集合的元素个数，但是这是没有必要的，因为除了根结点外，其他的结点无需保存集合元素个数，这样一个更好的方法便是：将集合的根结点的Parent设置为当前集合元素个数的负数。这样的话，合并的时候只需要取其绝对值参与运算即可。

说完了Union的优化，我们来考虑一下Find操作是否可以优化，答案是肯定的，就是所谓的路径压缩，每次查找一个结点的时候，将其查找路径上的全部结点直接指向其父节点。后面我会写一篇PAT树部分的习题解答，关于这两个操作优化后的具体实现可以在里面找到。

 

(END_XPJIANG)