第 5 章 树和二叉树
本章的主要内容是
5.1 树的逻辑结构
树的定义
树：n（n≥0）个结点的有限集合。当n＝0时，称为空树；任意一棵非空树满足以下条件：
⑴ 有且仅有一个特定的称为根的结点；
⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树。
树的基本术语
祖先、子孙：在树中，如果有一条路径从结点x到结点y，则x称为y的祖先，而y称为x的子孙。
层序编号：将树中结点按照从上层到下层、同层从左到右的次序依次给他们编以从1开始的连续自然数。
有序树、无序树：如果一棵树中结点的各子树从左到右是有次序的，称这棵树为有序树；反之，称为无序树。
森林：m (m≥0)棵互不相交的树的集合。
树的抽象数据类型定义
树的应用很广泛，在不同的实际应用中，树的基本操作不尽相同。下面给出一个树的抽象数据类型定义的例子，简单起见，基本操作只包含树的遍历，针对具体应用，需要重新定义其基本操作。
ADT Tree
Data
树是由一个根结点和若干棵子树构成，
树中结点具有相同数据类型及层次关系
Operation
InitTree
前置条件：树不存在
输入：无
功能：初始化一棵树
输出：无
后置条件：构造一个空树
DestroyTree
前置条件：树已存在
输入：无
功能：销毁一棵树
输出：无
后置条件：释放该树占用的存储空间
PreOrder
前置条件：树已存在
输入：无
功能：前序遍历树
输出：树的前序遍历序列
后置条件：树保持不变
PostOrder
前置条件：树已存在
输入：无
功能：后序遍历树
输出：树的后序遍历序列
后置条件：树保持不变
endADT
树的遍历：从 根结点出发，按照某种 次 序访问树中所有结点，使得每个结点被访问一次且仅被访问一次前序遍历
树的前序遍历操作定义为：
若树为空，则空操作返回；否则
⑴ 访问根结点；
⑵ 按照从左到右的顺序前序遍历根结点的每一棵子树。后序遍历
树的后序遍历操作定义为：
若树为空，则空操作返回；否则
⑴ 按照从左到右的顺序后序遍历根结点的每一棵子树；
⑵ 访问根结点。
层序遍历
树的层序遍历操作定义为：
从树的第一层（即根结点）开始，自上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。
5.2 树的存储结构
双亲表示法
基本思想：用一维数组来存储树的各个结点（一般按层序存储），数组中的一个元素对应树中的一个结点，包括结点的数据信息以及该结点的双亲在数组中的下标。
template <class DataType>
struct PNode
{
DataType data; //数据域
int parent; //指针域，双亲在数组中的下标
} ;
孩子链表表示法
struct CTNode
{
int child;
CTNode *next;
};
template <class DataType>
struct CBNode
{
DataType data;
CTNode *firstchild;
};
5.3二叉树的逻辑结构
二叉树的定义
二叉树是n(n≥0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
二叉树的特点
⑴ 每个结点最多有两棵子树；
⑵ 二叉树是有序的，其次序不能任意颠倒。
二叉树的基本性质
性质5-1 二叉树的第i层上最多有2i-1个结点（i≥1）。
性质5-2 一棵深度为k的二叉树中，最多有2k-1个结点，最少有k个结点。
性质5-3 在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。
性质5-4 具有n个结点的完全二叉树的深度为 log2n +1。
性质5-5 对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为i（1≤i≤n）的结点（简称为结点i），有：
（1）如果i＞1，则结点i的双亲结点的序号为 i/2；如果i＝1，则结点i是根结点，无双亲结点。
（2）如果2i≤n，则结点i的左孩子的序号为2i；
如果2i＞n，则结点i无左孩子。
（3）如果2i+1≤n，则结点i的右孩子的序号为2i+1；如果2i+1＞n，则结点i无右孩子。
完全二叉树的基本性质对一棵具有n个结点的完全二叉树中从1开始按层序编号，则
二叉树的抽象数据类型定义
ADT BiTree
Data
由一个根结点和两棵互不相交的左右子树构成，
结点具有相同数据类型及层次关系
Operation
InitBiTree
前置条件：无
输入：无
功能：初始化一棵二叉树
输出：无
后置条件：构造一个空的二叉树
DestroyBiTree
前置条件：二叉树已存在
输入：无
功能：销毁一棵二叉树
输出：无
后置条件：释放二叉树占用的存储空间
PreOrder
前置条件：二叉树已存在
输入：无
功能：前序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
InOrder
前置条件：二叉树已存在
输入：无
功能：中序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
PostOrder
前置条件：二叉树已存在
输入：无
功能：后序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
LeverOrder
前置条件：二叉树已存在
输入：无
功能：层序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
endADT
二叉树的遍历操作
前序（根）遍历
若二叉树为空，则空操作返回；否则：
①访问根结点；
②前序遍历根结点的左子树；
③前序遍历根结点的右子树。
中序（根）遍历
若二叉树为空，则空操作返回；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树。
后序（根）遍历
若二叉树为空，则空操作返回；否则：
①后序遍历根结点的左子树；
②后序遍历根结点的右子树。
③访问根结点；
层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，前序遍历结果：- + a * b - c d / e f
中序遍历结果：a + b * c - d - e / f
后序遍历结果：a b c d - * + e f / -
5.4二叉树的存储结构及实现
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。
二叉链表
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
template <class DataType>
struct BiNode
{
DataType data;
BiNode<T> *lchild, *rchild;
};
template <class DataType>
class BiTree
{
public:
BiTree( ){root = Creat(root);} //构造函数，建立一棵二叉树
~BiTree(){Release(root);} //析构函数
void PreOrder( ){PreOrder(root);} //前序遍历二叉树
void InOrder( ){InOrder(root);} //中序遍历二叉树
void PostOrder( ){PostOrder(root);} //后序遍历二叉树
void LeverOrder( ); //层序遍历二叉树
private:
BiNode<DataType> *root; //指向根结点的头指针
BiNode<DataType> *Creat(BiNode<DataType> *bt); //构造函数调用
void Release(BiNode<DataType> *bt); //析构函数调用
void PreOrder(BiNode<DataType> *bt); //前序遍历函数调用
void InOrder(BiNode<DataType> *bt); //中序遍历函数调用
void PostOrder(BiNode<DataType> *bt); //后序遍历函数调用
};
前序遍历——递归算法
template <class DataType>
void BiTree<DataType> :: PreOrder(BiNode<DataType> *bt)
{
if (bt == NULL) return; //递归调用的结束条件
else {
cout << bt->data; //访问根结点bt的数据域
PreOrder(bt->lchild); //前序递归遍历bt的左子树
PreOrder(bt->rchild); //前序递归遍历bt的右子树
}
}
中序遍历——递归算法
template <class DataType>
void BiTree<DataType> :: InOrder (BiNode<DataType> *bt)
{
if (bt == NULL) return; //递归调用的结束条件
else {
InOrder(bt->lchild); //中序递归遍历bt的左子树
cout << bt->data; //访问根结点bt的数据域
InOrder(bt->rchild); //中序递归遍历bt的右子树
}
}
后序遍历——递归算法
template <class DataType>
void BiTree<DataType> :: PostOrder(BiNode<DataType> *bt)
{
if (bt == NULL) return; //递归调用的结束条件
else {
PostOrder(bt->lchild); //后序递归遍历bt的左子树
PostOrder(bt->rchild); //后序递归遍历bt的右子树
cout << bt->data; //访问根结点bt的数据域
}
}
层序遍历
2. 如果二叉树非空，将根指针入队；
3. 循环直到队列Q为空
3.1 q=队列Q的队头元素出队；
3.2 访问结点q的数据域；
3.3 若结点q存在左孩子，则将左孩子指针入队；
3.4 若结点q存在右孩子，则将右孩子指针入队；
template <class DataType>
void BiTree<DataType>:: LeverOrder( )
{
front = rear = -1; //采用顺序队列，并假定不会发生上溢
if (root == NULL) return; //二叉树为空，算法结束
Q[++rear] = root; //根指针入队
while (front != rear) //当队列非空时
{
q = Q[++front]; //出队
cout << q->data;
if (q->lchild != NULL) Q[++rear] = q->lchild;
if (q->rchild != NULL) Q[++rear] = q->rchild;
}
}
构造函数——建立二叉树
遍历是二叉树各种操作的基础，可以在遍历的过程中进行各种操作，例如建立一棵二叉树。
template <class DataType>
BiTree :: BiTree( )
{
root = Creat(root);
}
template <class DataType>
BiNode<DataType> *BiTree<DataType>::Creat(BiNode<DataType> *bt)
{
cin >> ch; //输入结点的数据信息，假设为字符
if (ch == '# ') bt = NULL; //建立一棵空树
else {
bt = new BiNode; bt->data= ch; //生成一个结点，数据域为ch
bt->lchild = Creat(bt->lchild); //递归建立左子树
bt->rchild = Creat(bt->rchild); //递归建立右子树
}
return bt;
}
遍历二叉树是二叉树各种操作的基础，遍历算法中对每个结点的访问操作可以是多种形式及多个操作，根据遍历算法的框架，适当修改访问操作的内容，可以派生出很多关于二叉树的应用算法。
void InOrder (BiNode<T> *root)
{
if (root==NULL) return;
else {
InOrder(root->lchild);
cout<<root->data;
InOrder(root->rchild);
}
}
设计算法求二叉树的结点个数。
void Count(BiNode *root) //count为全局量并已初始化为0
{
if (root == NULL)return;
else {
Count(root->lchild);
count++;
Count(root->rchild);
}
}
设计算法按前序次序打印二叉树中的叶子结点
void PreOrder(BiNode *root)
{
if (root == NULL)return;
else {
if (!root->lchild && !root->rchild)
cout<<root->data;
PreOrder(root->lchild);
PreOrder(root->rchild);
}
}
设计算法求二叉树的深度。
int Depth(BiNode *root)
{
if (root == NULL)return 0;
else {
hl=Depth(root->lchild);
hr= Depth(root->rchild);
return max(hl,hr)+1;
}
}
设计算法求树中结点 x 的第 i 个孩子TNode *Search(TNode *root, DataType x, int i)
{
if (root->data== x) {
j=1;
p=root->firstchild;
while (p!=NULL&& j<i)
{
j++;
p=p->rightsib;
}
if (p != NULL)return p;
else returnNULL;
}
Search(root->firstchild, x, i);
Search(root->rightsib, x, i);
}
线索二叉树
二叉树的遍历方式有4种，故有4种意义下的前驱和后继，相应的有4种线索二叉树：
⑴ 前序线索二叉树
⑵ 中序线索二叉树
⑶ 后序线索二叉树
⑷ 层序线索二叉树
中序线索链表类的声明
template <class DataType>
class InThrBiTree
{
public:
InThrBiTree( ); //构造函数，建立中序线索链表
~ InThrBiTree( ); //析构函数，释放各结点的存储空间
ThrNode *Next(ThrNode<DataType>*p); //查找p的后继
void InOrder(); //中序遍历线索链表
private:
ThrNode *root; //指向线索链表的头指针
ThrNode<DataType> *Creat(ThrNode<DataType> *bt);
void ThrBiTree(ThrNode<DataType> *bt,
ThrNode<DataType> *pre); //构造函数调用
};
中序线索链表的建立
在遍历过程中，访问当前结点root的操作为：
⑴如果root的左、右指针域为空，则将相应标志置1；
⑵若root的左指针域为空，则令其指向它的前驱，这需要设指针pre始终指向刚刚访问过的结点，显然pre的初值为NULL；若pre的右指针域为空，则令其指向它的后继，即当前访问的结点root;
⑶ 令pre指向刚刚访问过的结点root；
中序线索链表的建立——构造函数
1. 建立二叉链表，将每个结点的左右标志置为0；
2. 遍历二叉链表，建立线索；
2.1 如果二叉链表root为空，则空操作返回；
2.2 对root的左子树建立线索；
2.3 对根结点root建立线索；
2.3.1 若root没有左孩子，则为root加上前驱线索;
2.3.2若root没有右孩子，则将root右标志置为1；
2.3.3若结点pre右标志为1，则为pre加上后继线索；
2.3.4 令pre指向刚刚访问的结点root；
2.4 对root的右子树建立线索。
中序线索链表的建立——构造函数
template <class DataType>
void InThrBiTree<DataType>::ThrBiTree(ThrNode<DataType> *bt,
ThrNode<DataType> *pre)
{
if (bt == NULL) return;
ThrBiTree(bt->lchild,pre);
if (bt->lchild == NULL) { //对bt的左指针进行处理
bt->ltag = 1;
bt->lchild = pre; //设置pre的前驱线索
}
if (bt->rchild == NULL) bt->rtag = 1; //对bt的右指针进行处理
if (pre->rtag == 1) pre->rchild = bt; //设置pre的后继线索
pre = bt;
ThrBiTree(bt->rchild,pre);
}
中序线索链表查找后继
⑴如果结点p的右标志为1，则表明该结点的右指针是线索；
⑵如果结点p的右标志为0，则表明该结点有右孩子。根据中序遍历的操作定义，它的后继结点应该是遍历其右子树时第一个访问的结点，即右子树中的最左下结点。
template <class DataType>
ThrNode<DataType> *InThrBiTree<DataType>:: Next(
ThrNode<DataType> *p)
{
if (p->rtag == 1)
q = p->rchild; //右标志为1，可直接得到后继结点
else {
q = p->rchild; //工作指针q指向结点p的右孩子
while (q->ltag ==0) //查找最左下结点
q = q->lchild;
}
return q;
}
5.5 二叉树遍历的非递归算法
前序遍历——非递归算法
二叉树前序遍历的非递归算法的关键：在前序遍历过某结点的整个左子树后，如何找到该结点的右子树的根指针。
解决办法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。
前序遍历——非递归算法
template <class DataType>
void BiTree::PreOrder(BiNode<DataType> *root)
{
top = -1; //采用顺序栈，并假定不会发生上溢
while (root != NULL || top != -1)
{
while (root !=NULL)
{
cout<<root->data;
s[++top] =root;
root =root->lchild;
}
if (top != -1){
root =s[top--];
root =root->rchild;
}
}
}
中序遍历——非递归算法
template <class DataType>
void BiTree::PreOrder(BiNode<DataType> *root)
{
top = -1; //采用顺序栈，并假定不会发生上溢
while (root != NULL || top != -1)
{
while (root !=NULL)
{
s[++top] =root;
root =root->lchild;
}
if (top != -1){
root =s[top--];
cout<<root->data;
root =root->rchild;
}
}
}
后序遍历——非递归算法
template <class DataType>
void BiTree<DataType> :: PostOrder(BiNode<DataType> *bt)
{
top = -1; //采用顺序栈，并假定栈不会发生上溢
while (bt != NULL || top != -1) //两个条件都不成立才退出循环
{
while (bt != NULL)
{
top++;s[top].ptr = bt; s[top].flag = 1; //root连同标志flag入栈
bt = bt->lchild;
}
while (top !=-1 && s[top].flag == 2)
{
bt = s[top--].ptr; cout << bt->data;
}
if (top !=-1) {
s[top].flag = 2; bt =s[top].ptr->rchild;
}
}
}
5.6 树、森林与二叉树的转换
树转换为二叉树
⑴加线——树中所有相邻兄弟之间加一条连线。
⑵去线——对树中的每个结点，只保留它与第一个孩子结点之间的连线，删去它与其它孩子结点之间的连线。
⑶层次调整——以根结点为轴心，将树顺时针转动一定的角度，使之层次分明。
森林转换为二叉树
⑴ 将森林中的每棵树转换成二叉树；
⑵ 从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。
⑴ 加线——若某结点x是其双亲y的左孩子，则把结点x的右孩子、右孩子的右孩子、……，都与结点y用线连起来；
⑵去线——删去原二叉树中所有的双亲结点与右孩子结点的连线；
⑶ 层次调整——整理由⑴、⑵两步所得到的树或森林，使之层次分明。
森林有两种遍历方法：
⑴前序（根）遍历：前序遍历森林即为前序遍历森林中的每一棵树。
⑵后序（根）遍历：后序遍历森林即为后序遍历森林中的每一棵树。
5.7 哈夫曼树及哈夫曼编码
相关概念
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为：
哈夫曼树： 给定一组具有确定权值的 叶子 结点，带权路径长度最小的二叉树
哈夫曼树的特点：
1. 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。
2. 只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点.
哈夫曼算法基本思想：
⑴ 初始化：由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}；
⑵ 选取与合并：在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和；
⑶ 删除与加入：在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中；
⑷ 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树。
伪代码
右孩子都置为-1；
2. 数组huffTree的前n个元素的权值置给定值w[n]；
3. 进行n-1次合并
3.1 在二叉树集合中选取两个权值最小的根结点，
其下标分别为i1, i2；
3.2 将二叉树i1、i2合并为一棵新的二叉树k；
void HuffmanTree(element huffTree[ ], int w[ ], int n ) {
for (i = 0; i <2*n-1; i++) {
huffTree [i].parent = -1;
huffTree [i].lchild = -1;
huffTree [i].rchild = -1;
}
for (i = 0; i < n;i++)
huffTree[i].weight= w[i];
for (k = n; k < 2*n-1; k++) {
Select(huffTree, i1, i2);
huffTree[k].weight= huffTree[i1].weight+huffTree[i2].weight;
huffTree[i1].parent= k; huffTree[i2].parent= k;
huffTree[k].lchild = i1; huffTree[k].rchild = i2;
}
}
哈夫曼树应用——哈夫曼编码
本章总结
745
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
