大话数据结构笔记——第六章：树

之前一直在谈论一对一的线性结构，现在来研究一对多的数据结构——树（Tree）

树的定义

树（Tree）是n(n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中：

1. 有且仅有一个特定的称为根(Root)的结点。
2. 当n>1时，其余结点可分为m(m>0)个互不相交的有限集$T_1$、$T_2$……$T_m$，其中每个集合本身又是一棵树，并且称为根的子树(SubTree)。

注意：根结点具有唯一性；子树的个数没有限制，但它们一定是不相交的。

结点分类

结点拥有的子树数称为结点的度（Degree）。度为0的结点称为叶结点（Leaf）或终端结点；度不为0的结点称为非终端结点或分支结点。除根节点外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。

结点间关系

结点的子树的根称为该结点的孩子（Child），相应地，该结点称为孩子的双亲（Parent）。同一个双亲的孩子之间互称为兄弟（Sibling）。结点的祖先是从根结点到该结点所经分支上的所有结点；反之，以某节点为根的子树中的任一结点都称为该结点的子孙。

树的其他相关概念

结点的层次（Level）从根开始定义起，根为第一层，根的孩子为第二层。双亲在同一层的结点互为堂兄弟。树中结点的最大层次称为树的深度（Depth）或高度。
如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。
森林（Forest）是m(m>=0)棵互不相交的树的集合。

线性结构与树结构区别

线性结构：

1. 第一个数据元素：无前驱
2. 最后一个数据元素：无后继
3. 中间数据元素：一个前驱一个后继

树结构：

1. 根节点：无双亲，唯一
2. 叶结点：无孩子，可以多个
3. 中间结点：一个双亲多个孩子

树的抽象数据类型

ADT 树(tree)
Data
	树是由一个根节点和若干棵子树构成。树中结点具有相同数据类型及层次关系
Operation.
	InitTree(*T):构造空树T
	DestroyTree(*T):销毁树T
	CreateTree(*T,definition):按definition中给出树的定义来构造树
	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是树T的非根结点，则返回它的双亲，否则返回空
	LeftChild(T,cur_e):若cur_e是树T的非叶结点，则返回它的左孩子，否则返回空
	RightChild(T,cur_e):若cur_e有右兄弟，则返回它的右兄弟，否则返回空
	InsertChild(*T,*p,i,c):其中p指向树T的某个结点，i为所指结点p的度加上1，
	非空树c与T不相交，操作结果为插入c为树T中p指结点的第i棵子树
	DeleteChild(*T,*p，i):其中p指向树T的某个结点，i为所指结点p的度,操作结果
	为删除T中p所指结点的第i棵子树。
endADT

树的存储结构

简单顺序存储结构和链式存储结构都无法对树进行存储，但是可以充分利用它们的特点实现对树存储结构的表示，这里介绍三种表示法：双亲表示法、孩子表示法、孩子兄弟表示法。

双亲表示法

以一组连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点在数组中的位置。

data	parent

结构代码：

/*树的双亲表示法结点结构定义*/
#define MAX_TREE_SIZE 100
typedef int TElemType; //树节点的数据类型
typedef struct PTNode //结点结构
{
	TElemType data;	//结点数据
	int parent; 	//双亲位置
}PTNode;
typedef struct 
{
	PTNode nodes[MAX_TREE_SIZE]; //结点数组
	int r,n //根的位置和节点数
}PTree;

根据结点的parent指针容易找到其双亲结点，时间复杂度为O(1)，但是如果要知道结点的孩子是什么，需要遍历整个结构才行。
可以增加一个结点给最左边孩子的域进行改进，可以称为长子域，没有的话设置为-1。

data	parent	firstchild

另一个问题，我们可能很关注各兄弟之间的关系，可以增加一个右兄弟域来体现兄弟关系，如果没有的话就赋值为-1。

data	parent	rightsib

这个域到底是指向什么得可以根据自己需要进行设计，存储结构的设计是一个非常灵活的过程，一个存储结构设计得是否合理，取决于基于该存储结构得运算是否适合、是否方便，时间复杂度好不好等。

孩子表示法

换一种完全不同得考虑方法。由于树中每个结点可能有多棵子树，可以考虑用多重链表，即每个每个结点有多个指针域，其中每个指针指向一棵子树的根结点，我们把这种方法叫做多重链表表示法，根据结点度的不同，可以有两种解决方案。

• 方案一

data	child1	child2	……	childn

data是数据域，child1……childn是指针域，这种方案当树中结点的度相差很大时，会造成空间浪费，很多结点它的指针域可能会空出很多；如果各结点的度差异很小时，这种方案很适用。因此引出第二种方案。

• 方案二

data	degree	child1	……	childn

data是数据域，degree为度域，存储着每个结点的孩子结点的个数，child1到childn为指针域。

• 孩子表示法

把每个结点的孩子结点排列起来，以单链表做存储结构，则n个结点有n个孩子链表，如果是叶子结点则此单链表为空。然后n个头指针有组成一个线性表，采用顺序存储结构，存放进一个一维数组中。
设计两种结点结构：

child	next

										孩子链表的孩子结点

data	firstchild

										表头数组的表头结点

结构代码：

/*数的孩子表示法结构定义*/
#define MAX_TREE_SIZE 100
typedef struct CTNode //孩子节点
{
	int child;
	struct CTNode *next;
}*ChildPtr;
typedef struct  //表头结构
{
	TElemType data;
	ChildPtr firstchild;
}CTBox;
typedef struct //树结构
{
	CTBox nodes[MAX_TREE_SIZE]; //节点数组
	int r,n;//根的位置和结点数
}CTree;

孩子兄弟表示法

通过观察发现，任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设计两个指针，分别指向该结点的第一个孩子和此结点的兄弟。

data	firstchild	rightsib

data是数据域，firstchild是指针域，存储该结点的第一个孩子结点的存储地址，rightsib是指针域，存储该结点的右兄弟结点的存储位置。

二叉树的定义

二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的，分别称为根节点的左子树和右子树的二叉树组成。

特点

• 每个结点最多有两棵子树，即二叉树中不存在度大于2的结点。
• 左子树和右子树是有顺序的，次序不能任意颠倒。
• 即使树中某个结点只有一棵子树，也要区分它是左子树还是右子树。
• 二叉树具有五种基本形态：
• 空二叉树
• 只有一个根节点
• 只有左子树
• 只有右子树
• 既有左子树又有右子树

特殊二叉树

• 斜树：所有子树都在树的一边，左边或者右边，分别称为左斜树，右斜树统称为斜树。
• 满二叉树：在一棵二叉树中，如果所有分支结点都存在左右子树，且所有的叶子都在同一层，这样的二叉树称为满二叉树。
• 完全二叉树：对一棵具有n个结点的二叉树按层序编号（从上到下，从左到右），如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同，则此二叉树为完全二叉树。
  完全二叉树特点：
• 叶子只能出现在最下两层。
• 最下层的叶子一定集中在左部连续位置。
• 倒数两层，若有叶子结点，一定都在右部连续位置。
• 如果结点度为1，则该结点只有左孩子，即不存在只有右子树的情况。
• 同样结点数的二叉树，完全二叉树的深度最小。

二叉树的性质

1. 在二叉树的第i层上至多有2^i-1结点（i>=1）；
2. 深度为k的二叉树至多有2^k-1个节点（k>=1）；
3. 对任何一棵二叉树T，如果其终端结点数为$n_0$，度为2的结点数为$n_2$，则$n_0$=$n_2$+1；
4. 具有n个结点的完全二叉树的深度为|$lo{g}_2$n|+1(| |代表取整操作)；
5. 如果对一棵有n个结点的完全二叉树（其深度为|$lo{g}_2$n|+1）的结点按层序编号（从第1层到第|$lo{g}_2$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

二叉树的存储结构

二叉树的顺序存储结构

使用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组下标要能体现结点之间的逻辑关系。完全二叉树由于是严格的按层序编号，所以使用顺序结构可以表现出来二叉树的结构。对于一般的二叉树，尽管层序编号不能反映逻辑关系，但是可以将其按完全二叉树编号，只不过，把不存在的结点设置为"V"而已。但是注意这种存储方式对一棵右斜树来说，会造成很大的存储空间的浪费。所以顺序存储结构一般只用于完全二叉树。

二叉链表

二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域，我们称这样的链表为二叉链表。

lchild	data	rchild

data是数据域，lchild和rchild都是指针域，代表着左孩子、右孩子。

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

如果有需要还可以增加一个指向其双亲的指针域，这样就称为三叉链表。

遍历二叉树

遍历原理

二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树的所有结点，使得每个结点被访问一次且仅被访问一次。由于二叉树的节点之间不存在唯一的前驱后继关系，所以二叉树的遍历不同于线性结构，将会面临很多的选择问题。

二叉树的遍历方法

二叉树遍历方法很多，不过如果限制了从左到右的习惯方式，那么主要的遍历方式能分为四种

前序遍历

若二叉树为空，则空操作返回，否则先访问根节点，然后前序遍历左子树，再前序遍历右子树。也就是左边的全部遍历完再遍历右边的。

中序遍历

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

后序遍历

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

层序遍历

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

对于计算机来说，它只会处理线性序列，这四种遍历方式，都是把书中的结点变成某种意义的线性序列，这给程序的实现带来了好处。

前序遍历算法

/*二叉树的前序遍历递归算法*/
void PreOrderTraverse(BiTree T)
{
	if (T==NULL)
	{
		return;
	}
	printf("%c"，T->data); //显示结点数据，可以更改为其他对结点操作
	PreOrderTraverse(T->lchild); //再先序遍历左子树
	PreOrderTraverse(T->rchild);//最后先序遍历右子树
}

中序遍历算法

/*二叉树的中序遍历递归算法*/
void InOrderTraverse(BiTNode T)
{
	if (T==NULL)
	{
		return;
	}
	InOrderTraverse(T->lchild); //中序遍历左子树
	printf("%c",T->data );//显示结点数据，可以更改为其他对结点操作
	InOrderTraverse(T->rchild); //最后中序遍历右子树
}

后序遍历算法

/*二叉树的后序遍历递归算法*/
void PostOrderTraverse(BiTNode T)
{
	if (T==NULL)
	{
		return;
	}
	PostOrderTraverse(T->lchild); //先后序遍历左子树
	PostOrderTraverse(T->rchild); //再后序遍历右子树
	printf("%c",T->data );//显示结点数据，可以更改为其他对结点操作
}

推导遍历结果

在充分理解前、中、后序遍历的情况下，已知两个遍历结果求后一种遍历结果（但是注意，已知前序和后序遍历是不能确定一棵二叉树），相当于根据遍历结果把树确定下来。

二叉树的建立

实现算法：

/*按前序输入二叉树中结点的值（一个字符）*/
/*#表示空树，构造二叉链表表示二叉树T*/
void CreateBiTree(BiTNode *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个结点的二叉树一共有n-1条分支线数，也就是说，存在n+1个空指针域。将这些空指针域利用起来，存放指向结点在某种遍历次序下的前驱和后继地址。把这种指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树，其实线索二叉树变成一个双向链表，我们对二叉树以某种次序遍历使其成为线索二叉树的过程称做是线索化。
我们再添上两个标志域，注意标志域只是存放0或1数字的布尔型变量，区分某个指针域到底指的是孩子域还是指向的是前驱域后继域，具体结构如下图：

lchild	ltag	data	rtag	rchild

• ltag为0时指向该结点的左孩子，为1时指向该结点的前驱。
• rtag为0时指向该结点的右孩子，为1时指向该结点的后继。

线索二叉树结构实现

结构定义代码:

/*二叉树的二叉线索存储结构定义*/
typedef enum{Link,Thread} PointerTag; 
/*Link==0表示指向左右孩子的指针*/
/*Thread==1表示指向前驱或后继的线索*/
typedef struct BiThrNode //二叉线索存储结点结构
{
	TElemType 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; //左孩子指针指向前驱
		}
		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) //
	{
		while(p->LTag==Link) //当LTag==0时循环到中序序列第一个结点
			p=p->lchild;
		printf("%c",p->data ); //显示结点数据，可以更改为其他对结点的操作
		while(p->RTag==Thread && P->rchild!=T)
		{
			p=p->rchild;
			printf("%c",p->data );
		}
		p = p->rchild; //p进至其右子树根
	}
	return OK;
}

整个代码等于是一个链表的扫描，所以时间复杂度为O(n)。在实际问题中，如果所采用的二叉树需要经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

树、森林与二叉树的转换

树转换为二叉树

树转化为二叉树步骤：

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

森林转换为二叉树

步骤：

1. 把每棵树转化为二叉树。
2. 第一颗二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根节点的右孩子，用线连接起来。当所有的二叉树连接起来后就得到了由森林转换来的二叉树。

二叉树转换为树

1. 加线。若某结点的左孩子结点存在，则将这个左孩子的右孩子结点、右孩子的右孩子结点，右孩子的右孩子的右孩子的节点……，也就是左孩子的n个右孩子结点都作为此结点的孩子。将该结点与这些右孩子结点用线连接起来。
2. 去线。删除原二叉树中所有结点与其右孩子结点的连线。
3. 层次调整。使之结构层次分明。

二叉树转化为森林

步骤：

1. 从根结点开始，若右孩子存在，则把与右孩子结点的连线删除，再查看分离后的二叉树，若右孩子存在，则连线删除……，直到所有右孩子连线都删除为止，得到分离的二叉树。
2. 再将每棵分离后的二叉树转换为树即可。

树与森林的遍历

树的遍历分为两种：

1. 先根遍历树。
2. 后根遍历树。

森林遍历也为两种：

1. 前序遍历。
2. 后序遍历。
   森林的前序遍历和二叉树的前序遍历结果相同，森林的后序遍历和二叉树的中序遍历结果相同。
   树的先根遍历和后根遍历完全可以借用二叉树的前序遍历和中序遍历算法来实现。

赫夫曼树及其应用

定义与原理

需要把二叉树转化成叶子结点带权的二叉树，从树中一个结点到另一个结点之间的分支构成两个结点之间的路径，路径上的分支数目成为路径长度。树的路径长度就是从树根到每一结点的路径长度之和。如果考虑到带权的结点，结点的带权的路径长度为从该结点的树根之间的路径长度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和。将带权路径长度WPL最小的二叉树称做赫夫曼树，或称最优二叉树。