六、树

树

• 【树(Tree)】是n(n>=0)个结点的有限集。
  • 当n=0时成为空树，
  • 在任意一棵非空树中，有且仅有一个特定的称为根(Root)的结点；
  • 当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、…、Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree)。
• 【结点的度】：结点拥有的子树数
  • 【叶结点(Leaf)】或【终端结点】：度为0的结点
  • 【分支结点】或【非终端结点】：度不为0的结点
  • 【内部结点】：除根结点外，分支结点也
• 【树的度】：各个结点度的最大值
•  
  • 【孩子(Child)】：结点的子树的根
  • 【双亲(Parent)】：上述该结点
  • 【兄弟(Sibling)】：同一双亲的孩子们
  • 【结点的祖先】：是从根到该结点所经分支上的所有结点
  • 【结点的层次(Level)】：从根开始定一起，根为第一层，根的孩子为第二层
  • 【堂兄弟】：其双亲在同一层的结点
• 【树的深度(Depth)】或【高度】：树中结点的最大层次
•  
  • 【有序树】：子树从左至右是有序的
  • 【无序树】：子树从左至右是无序的
• 【森林】：m>=0棵不相交的树的集合

ADT

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

存储结构

• 一个存储结构设计得是否合理，取决于基于该存储结构的运算是否适合、是否方便，时间复杂度好不好等
• 根据运算需要，可增加如firstchild域、rightsib域等

双亲表示法

• 找双亲简单：根据节点的parent
• 找孩子难：遍历整棵树
• 【结点】：【data】数据域 + 【parent】指针域（存放双亲结点在数组中的位置）

#define MAX_TREE_SIZE 100
typedef int TElemType;              // 假设为int

typedef struct PTNode              // 结点结构
{
	TElemType data;	               // 数据域
	int parent;	               	   // 指针域
}PTNode;

typedef struct                	   // 树结构
{
	PTNode nodes[MAX_TREE_SIZE];   // 结点数组
	int r;						   // 根的位置
	int n;		                   // 结点数
}PTree;

孩子表示法

• 找孩子简单：查该结点孩子链表
• 找双亲难：遍历整棵树
• 把每个结点的孩子结点用单链表排列起来
  • n个结点有n个孩子链表
  • 叶结点的孩子链表为空
  • n个头指针组成数组存放的线性表
• 【孩子链表结点】：【child】数据域（结点在表头数组的下标） + 【next】指针域（下一个孩子结点的指针）
• 【表头数组结点】：【data】数据域 + 【firstchild】头指针域（孩子链表头指针）

#define MAX_TREE_SIZE 	100
typedef char TElemType;

typedef struct CTNode                   // 孩子结点
{
	int child;			                  
	struct CTNode *next;
} *ChildPtr;

typedef struct                          // 表头结构 
{	
	TElemType data;		
	int parent;			
	ChildPtr firstchild;	
} CTBox;

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

孩子兄弟表示法

• 找孩子简单：查该结点孩子链表
• 找双亲难：遍历整棵树
• 【结点】：【data】数据域 +【firstchild】指针域 +【rightsib】指针域

typedef struct CSNode
{
	TElemType data;
	struct CSNode *firstchild, *rightsib;
}CSNode,*CSTree;

二叉树

• 【二叉树】（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成
• 二叉树中不存在度大于2的结点
• 左子树和右子树是有顺序的，次序不能颠倒

五种基本形态

• 空二叉树
• 只有一个根结点
• 根结点只有左子树
• 根结点只有右子树
• 根结点既有左子树又有右子树

特殊二叉树

斜树

• 【左斜树】：所有结点只有左子树
• 【右斜树】：所有结点只有右子树

满二叉树

• 所有分支结点都存在左子树和右子树，且所有叶结点在同一层
  • 叶子只能出现在最下一层
  • 非叶子结点的度一定是2
  • 在同样深度的二叉树中，满二叉树的结点个数一定最多，同时叶子也是最多

完全二叉树

• 对一棵具有n个结点的二叉树按层序编号，如果编号为 i (1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点位置完全相同，则这棵二叉树称为完全二叉树
  • 叶子结点只能出现在最下两层。
  • 最下层的叶子一定集中在左部连续位置。
  • 倒数第二层，若有叶子结点，一定都在右部连续位置。
  • 如果结点度为1，则该结点只有左孩子。
  • 同样结点个数的二叉树，完全二叉树的深度最小

二叉树的性质

• 在二叉树的第 i 层上至多有2^(i-1)个结点(i>=1)
• 深度为 k 的二叉树至多有2^k-1个结点(k>=1)
• 对任何一棵二叉树T，如果其终端结点数为 n₀，度为2的结点数为 n₂，则n₀=n₂+1（n₀+n₁+n₂-1 = n₁+2*n₂）
• 具有 n 个结点的完全二叉树的深度为 ⌊log₂n⌋+1
• 对一棵有n个结点的完全二叉树(其深度为⌊log₂n⌋+1)的结点按层序编号，对任一结点 i (1<=i<=n)有以下性质：
  1. 如果i = 1，则结点 i 是二叉树的根，无双亲；如果i > 1，则其双亲是结点⌊i/2⌋
  2. 如果2i > n，则结点 i 无做左孩子(结点 i 为叶子结点)；否则其左孩子是结点2i
  3. 如果2i+1 > n，则结点 i 无右孩子；否则其右孩子是结点2i+1

存储结构

• 二叉树是一种特殊的树，由于它的特殊性，使得用顺序存储结构或链式存储结构都能够简单实现

顺序存储

• 用一维数组存储二叉树中的各个结点，并且结点的存储位置能体现结点之间的逻辑关系
• 把不存在的结点用 “^” 代替
• 一般只用于完全二叉树
  

二叉链表

• 【结点】：【lchild】指针域 +【data】数据域 +【rchild】指针域

typedef struct BiTNode          // 结点结构
{
	ElemType data;
	struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

二叉树的遍历

• 从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次
• 不同的遍历提供了对结点依次处理的不同方式，可在遍历过程中对结点进行各种处理

前序遍历NLR

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

/* NLR递归算法 */
void PreOrderTraverse(BiTree T){
	if(T==NULL)
		return;
	printf("%c\t",T->data);
	PreOederTraverse(T->lchild);
	PreOederTraverse(T->rchild);
}

中序遍历LNR

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

/* LNR递归算法 */
void InOrderTraverse(BiTree T){
	if(T==NULL)
		return;
	InOrderTraverse(T->lchild);
	printf("%c\t",T->data);
	InOrderTraverse(T->rchild);
}

后序遍历LRN

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

/* LRN递归算法 */
void PostOrderTraverse(BiTree T){
	if(T==NULL)
		return;
	PostOrderTraverse(T->lchild);
	PostOrderTraverse(T->rchild);
	printf("%c\t",T->data);
}

层序遍历

• 若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问

二叉树的建立

输入序列：AB#D##C##

/* 按NLR输入结点值 */
/* #表示空树，递归构造二叉链表表示二叉树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);	
	}
}

线索二叉树

• n个结点的二叉树有2n-(n-1) = 【n+1】个【空指针域】
• 【线索】：指向前驱和后继的指针
• 【结点】：【lchild】+【ltag】+【data】+【rtag】+【rchild】
  • 【ltag】为 0 时指向该结点的左孩子，为 1 时指向该结点的前驱
  • 【rtag】为 0 时指向该结点的右孩子，为 1 时指向该结点的后继
• 线索化过程就是在遍历的过程中修改指针的过程
• 线索二叉链表的存储结构利于遍历或查找某种遍历序列的前驱和后继

存储结构

typedef enum {Link, Thread} PointerTag;  // Link==0 表示指向左右孩子的指针
                                         // Thread==1 表示指向前驱或后继的线索
typedef struct BiThrNode          // 二叉线索存储结点结构
{
	char 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;            // 左孩子指向前驱， pre在之前初始化为头指针
		}

		if( !pre->rchild )              // 前驱没有右孩子
		{
			pre->rtag = Thread;         // 后继线索
			pre->rchild = p;            // 前驱右孩子指针指向后继(p)
		}

		pre = p;                        // 保持pre指向p的前驱

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

中序遍历中序线索二叉树

/* T指向头结点，头结点左链lchild指向根节点，右链rchild指向中序遍历最后一个结点 */
/* 中序遍历二叉线索链表表示的二叉树T */
Status InOrderTraverse_Thr( BiThrTree T )
{
	BiThrTree p;
	p = T->lchild;                      // p指向根结点

	while( p != T )                     // 空树或遍历结束时，p==T
	{
		while( p->ltag == Link )        // ltag==0时循环到中序序列第一个结点
		{
			p = p->lchild;
		}
		printf("%c\t",p->data);         // 显示结点数据，可改为其他对结点的操作

		while( p->rtag == Thread && p->rchild != T )
		{
			p = p->rchild;
			visit(p->data);
		}
		
		p = p->rchild;                  // p进其右子树根
	}
	return OK;
}

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;

typedef enum {Link, Thread} PointerTag;       // 枚举类型默认值{0,1}

typedef struct BiThrNode         // binary thread
{
	char data;
	struct BiThrNode *lchild, *rchild;
	PointerTag ltag;
	PointerTag rtag;
} BiThrNode, *BiThrTree;          // 取两个不同类型的别名

BiThrTree pre;   // 全局变量指向刚刚访问的结点

// 按照前序遍历的方式输入数据,建立二叉树
void CreateBiThrTree( BiThrTree *T )
{
	char c;

	scanf("%c", &c);
	if( ' ' == c )
	{
		*T = NULL;
	}
	else
	{
		*T = (BiThrNode *)malloc(sizeof(BiThrNode));
		(*T)->data = c;
		(*T)->ltag = Link;
		(*T)->rtag = Link;

		CreateBiThrTree(&(*T)->lchild);
		CreateBiThrTree(&(*T)->rchild);
	}
}

// 中序遍历线索化
void InThreading(BiThrTree T)
{
	if( T )
	{
		InThreading( T->lchild );		// 递归左孩子线索化

		if( !T->lchild )
		{
			T->ltag = Thread;
			T->lchild = pre;            // pre在之前初始化为头指针
		}

		if( !pre->rchild )
		{
			pre->rtag = Thread;
			pre->rchild = T;
		}

		pre = T;

		InThreading( T->rchild );		// 递归右孩子线索化
	}
}

// pre初始化为头指针
void InOrderThreading( BiThrTree *p, BiThrTree T )
{
	*p = (BiThrTree)malloc(sizeof(BiThrNode));
	(*p)->ltag = Link;
	(*p)->rtag = Thread;
	(*p)->rchild = *p;                  // p为头指针
	if( !T )
	{
		(*p)->lchild = *p;              // 空树指向自己
	}
	else
	{
		(*p)->lchild = T;               // 如图 1
		pre = *p;
		InThreading(T);                 // 调用中序遍历线索化
		pre->rchild = *p;               // 如图 4
		pre->rtag = Thread;             // 如图 4
		(*p)->rchild = pre;             // 如图 2
	}
}

void visit( char c )
{
	printf("%c", c);
}

// 非递归的中序遍历
void InOrderTraverse( BiThrTree T )
{
	BiThrTree p;
	p = T->lchild;

	while( p != T )
	{
		while( p->ltag == Link )
		{
			p = p->lchild;
		}
		visit(p->data);                   // 根据实际需求可放其他对结点的操作

		while( p->rtag == Thread && p->rchild != T )
		{
			p = p->rchild;
			visit(p->data);
		}

		p = p->rchild;
	}
}

int main()
{
	BiThrTree P, T = NULL;          // p是头指针、T是根节点

	CreateBiThrTree( &T );

	InOrderThreading( &P, T );

	printf("中序遍历输出结果：");

	InOrderTraverse( P );

	printf("\n");

	return 0;
}

树、森林、二叉树的转换

树转为二叉树

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

森林转为二叉树

• 把每棵树转换为二叉树
• 第一棵二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子，用线连接起来

二叉树转为树

• 左孩子，右兄弟
• 二叉树转换为普通树是刚才的逆过程，连接双亲，断开兄弟

二叉树转为森林

• 判断一棵二叉树能够转换成一棵树还是森林，标准很简单，那就是只要看这棵二叉树的根结点有没有右孩子，有的话就是森林，没有的话就是一棵树
• 每棵树对应的二叉树分离后继续转为树

树与森林的遍历

树的遍历

• 先根遍历：先访问树的根结点，然后再依次先根遍历根的每棵子树
• 后根遍历：先依次遍历每棵子树，然后再访问根结点

森林的遍历

• 按照树的先根遍历和后根遍历依次访问森林的每一棵树
• 树、森林的前根（序）遍历和二叉树的前序遍历结果相同
• 树、森林的后根（序）遍历和二叉树的中序遍历结果相同

赫夫曼树

• WPL最小的二叉树
• 【压缩】：将文本重新编码，减少不必要的空间
• 【赫夫曼编码】：最基本的压缩编码方法，根据字符出现频率，利用赫夫曼编码可以构造出一种不等长的二进制，使编码后的电文长度最短，且保证不产生二义性
• 特点：
• 初始结点都成为叶结点，权值越小离根结点越远
• 新建n-1个结点
• 不存在度为1的结点
• 度为m的赫夫曼树只有度为0和m的结点
• 若 (n-1)%(m-1) == u != 0 需要补“0” m-u+1个

定义

• 【结点的路径长度】：从根结点到该结点的路径上的连接数
• 【树的路径长度】：树中每个叶子结点的路径长度之和
• 【结点带权路径长度】：结点的路径长度与结点权值的乘积
• 【树的带权路径长度WPL(Weighted Path Length)】：是树中所有叶子结点的带权路径长度之和
• WPL的值越小，说明构造出来的二叉树性能越优

赫夫曼算法描述

1. 为每个符号建立一个叶子节点，并加上其相应的发生频率
2. 当有一个以上的节点存在时，进行下列循环：
   1. 把这些节点作为带权值的二叉树的根节点，左右子树为空
   2. 选择两棵根结点权值最小的树作为左右子树构造一棵新的二叉树，且至新的二叉树的根结点的权值为其左右子树上根结点的权值之和
   3. 把权值最小的两个根节点移除
   4. 将新的二叉树加入队列中
3. 最后剩下的节点暨为根节点，此时二叉树已经完成

赫夫曼编码

• 根据赫夫曼树，从根结点开始，左 0 右 1
• 赫夫曼编码可以很有效地压缩数据（通常可以节省20%~90%的空间，具体压缩率依赖于数据的特性）
• 【定长编码】：像ASCII编码
• 【变长编码】：单个编码的长度不一致，可以根据整体出现频率来调节
• 【前缀码】：所谓的前缀码，就是没有任何码字是其他码字的前缀
• 赫夫曼编码是总长度最短的前缀码
• 解码时还要用到赫夫曼树，发送方接收方必须约定好同样的赫夫曼编码规则