树和二叉树
文章目录
树和二叉树的定义
树的定义
树（tree）是n个结点的有限集，树的定义适应递归的定义
n=0，称为空树
n>0 1.有且仅有一个特定称为根（root）的结点
2.其余结点可分为m个互不相交的有限集T1,T2,T3…Tm,其中每一个集合本身又是一棵树，并称为根的子树（subtree）
表示方式
嵌套集合，凹入表示，广义表
树的基本术语
-根节点：非空树中无前驱结点的结点
-结点的 度 ：结点拥有的子树数
-树的度：树内各结点的度的最大值
-叶结点：度为0，终端结点
-孩子结点(子节点)：一个结点的孩子结点是指这个结点的子树的根节点
-双亲结点(父节点)：一个结点的双亲结点是指，若树中某个结点有孩子
结点，则这个结点就成为是该孩子结点的双亲结点
-兄弟结点：指具有同一个双亲的结点
-堂兄弟结点：双亲在同一层次上的接地那互为堂兄弟
-祖先结点：一个结点的祖先结点是指该结点的路径中除该结点之外的所有结点
-树的深度：树中结点的最大层次，从下往上计算
-树的高度：从上往下计算
两者对于同一棵树来说，深度和高度一样，但是对于某个结点而言就不是这样子了
-有序树：是指树中各个结点的所有子树之间，从左到右有严格的次序关系，不能互换
-无序树：与有序树相反，树中各个结点的所有子树之间没有严格的次序关系
-森林：是m(m>=0)棵互不相交的树的集合，删除一棵树的根结点，这棵树就变成了一个森林，反之，在一个森林加上一个根结点，这个森林就变成了一颗树；树一定是森林，森林不一定是树
二叉树的定义
二叉树的结构最简单，规律性最强
可以证明，所有树都能转化为唯一对应的二叉树，不失一般性
二叉树是n(n>=0)个结点的有限集，是由一个根结点和两棵互不相交的分别称作根的左子树和右子树的二叉树组成
1.每个结点做多有两个孩子（二叉树中不存在度大于2的结点）
2.子树有左右之分，其次序不能颠倒
3.二叉树可以是空集合，跟可以有空的左子树或空的右子树
树和二叉树的抽象数据类型定义
ADT BinaryTree{
数据对象D：D是具有相同特性的数据元素的集合
数据关系R：其中每个结点只有一个前驱(除根结点)，可以有零个，一个或两个后继，有且仅有一个结点(根结点)没有前驱
基本操作：//至少20个！！！！
CreateBiTree(&T,definition),构造操作：按照definition构造二叉树T，其中definition给出二叉树的定义
PreOrderTraverse(T),先根遍历操作：按照先根遍历次序对二叉树T中的每个结点调用函数Visit()一次且至多一次。其中，Visit()是对结点操作的应用函数，一旦Visit()失败，则操作失败
InOrderTraverse(T),中根遍历操作：按照中根遍历次序对二叉树T中的每个结点调用函数Visit()一次且至多一次。其中，Visit()是对结点操作的应用函数，一旦Visit()失败，则操作失败
PostOrderTraverse(T),后根遍历操作：按照后根遍历次序对二叉树T中的每个结点调用函数Visit()一次且至多一次。其中，Visit()是对结点操作的应用函数，一旦Visit()失败，则操作失败
//还有很多，具体看书
}
二叉树的性质和存储结构
二叉树的性质
- 性质1
在二叉树的第i层上至多有2i-1个结点（i>=1) 归纳法证明
至少有一个结点 - 性质2
深度为k的二叉树至多有2k-1个结点（k>=1)
至少有k个结点 - 性质3
对任何一个二叉树T，如果其叶子树为n0，度为2的结点数为n2，则n0=n2+1
二叉树的特殊形式-满二叉树
一个深度为k且有2k-1个结点的二叉树称为满二叉树
- 特点1：每层上的结点数都是最大结点数（即每层都满）
- 特点2：叶子结点全部在最底层
对满二叉树结点位置进行编号
- 编号规则：从根结点开始，自上而下，自左向右
- 每一结点位置都有元素
二叉树的特殊形式-完全二叉树
深度为k的具有n个结点的二叉树，当且仅当每一个结点都与深度为k的满二叉树中的编号为1-n的结点一一对应时，称为完全二叉树（完全二叉树的逻辑结构与满二叉树的前n个结点的逻辑结构相同）
意思就是完全二叉树是由满二叉树从最后一个结点开始连续去掉任意个结点生成的==一定是要连续去掉！！！所以满二叉树是完全二叉树（满二叉树是完全二叉树的一种特例，满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树）
- 特点1：叶子只可能分布在层次最大的两层上
- 特点2：对任意结点，如果右子树的最大层次为i，则其左子树的最大层次必为i或i+1
- 特点3：结点总数为奇数时，度为1的个数为0；结点总数为偶数时，度为1的个数为1.
- 特点4：完全二叉树是具有n个结点的众多二叉树之中深度最小的一棵树
- 特点5：具有n个结点的完全二叉树的深度是[LOG2N]+1,[X]表示不大于x的最大整数
- 特点6：有一棵n个结点的完全二叉树，任一结点i（1<=i<=n）
1.如果i=1，则结点i是二叉树的根，无双亲，如果i>1,则其双亲结点时i/2
2.如果2i>n,则结点i为叶子结点，无左孩子否则其左孩子是结点2i
3.如果2i+1>n,则结点无右孩子，否则，其右孩子是结点2i+1
二叉树的顺序存储结构
实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素
二叉树的各个结点先按照一定的顺序排列成一个线性序列，再通过这些结点在线性序列中的相对位置，确定二叉树各个结点之间的逻辑关系。
对于一棵非完全二叉树来说，可以现在次树中增加一些并不存在的虚结点使其成为一棵完整的树，然后用与完全二叉树相同的方法对结点进行编号，再将编号为i的结点的值存放到数组下标为i-1的数组单元中。虚结点不放东西或者放0.
- 二叉树顺序存储表示
#define MAXTSIZE 100
Typedef TElemType SqBiTree[MAXTSIZE];//0号单元存储根结点
SqBiTree bt;
优点结构简单查找方便，但是浪费存储空间，特别是二叉树进行插入，删除结点操作时，会引起大量元素的移动。 对于完全二叉树或者满二叉树，这种顺序存储方式非常适合； 对于非完全二叉树来说，存储空间浪费，存储密度小
二叉树的链式存储结构
二叉树链式存储结构中的结点设置三个域：数据域，左孩子域和右孩子域
- 二叉链表存储结构表示
Typedef struct BiNode{
TElemType data;
struct BiNode *lchild,*rchild;//左孩子指针，右孩子指针
}BiNode，*BiTree；
在n个结点的二叉链表中，有
分析：必有2n个链域。除根结点外，每个结点有且仅有一个双亲，所以只会有n-1个结点的链域存放指针，指向非空子女结点
- 三叉链表存储结构表示
Typedef struct TriTNode{
TElemType data;
struct TriTNode *lchild,*parent,*rchild;//左孩子指针，指向双亲指针，右孩子指针
}TriTNode，*TriTree；
遍历二叉树和线索二叉树
若规定先左后右，则有三种情况
DLR-先（根）序遍历
LDR-中（根）序遍历
LRD-后（根）序遍历
先序遍历二叉树的操作定义
若二叉树为空，则空操作，否则
（1）访问根结点
（2）先序遍历左子树
（3）先序遍历右子树
中序遍历二叉树的操作定义
若二叉树为空，则空操作，否则
（1）中序遍历左子树
（2）访问根结点
（3）中序遍历右子树
后序遍历二叉树的操作定义
若二叉树为空，则空操作，否则
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根结点
根据遍历序列确定二叉树
由二叉树的先序序列和中序序列，或者后序序列和中序序列可以确定唯一一棵二叉树，但是知道先序和后序无法确定
知道两组序列后，先根据遍历操作定义找出根和接下来的每个子树的根然后一步一步往下推，以中序为目标然后一步一步往下画
遍历算法的实现-递归算法
在二叉链表上使用递归方法实现
先序遍历
void PreOrderTraverse(BiTree T)//传入根结点
{
if(T!=NULL)
{
printf("%c".T->data);//也可以用函数visit()自定义函数输出数据域里面的值
PreOrderTraverse(T->lchild);//递归先序遍历左子树
PreOrderTraverse(T->rchild);//递归先序遍历右子树
}
}
中序遍历
void InOrderTraverse(BiTree T)
{
if(T!=NULL)
{
InOrderTraverse(T->lchild);
printf("%c".T->data);
InOrderTraverse(T->rchild);
}
}
后序遍历
void PostOrderTraverse(BiTree T)
{
if(T!=NULL)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c".T->data);
}
}
- 遍历算法分析（递归方式）
去掉输出语句，从递归角度看，三种算法完全一样，访问路径都是相同的，只是访问结点时机不同，结构简单，但是时间空间开销较大，运行效率低
时间复杂度O(n)
空间复杂度O(n)
遍历算法的实现-非递归算法
就是利用栈的后进先出的特点。
先根遍历-非递归
Status NPreRootTraverse(BiTree T)
{
SqStack S;//创建一个栈
InitStack(S);//初始化顺序栈
while(!StackEmpty(S)||(T!=NULL))
{
if(T!=NULL)
{
printf("%c",T->data);//先输出根结点
Push(S,T);//将根入栈
T=T->lchild;//指向左子树的根结点
}
else
{
Pop(S,T);//出栈
T=T->rchild;//指向右孩子
}
}
return OK;
}
中根遍历-非递归
Status NInRootTraverse(BiTree T)
{
SqStack S;
InitStack(S);
while(!StackEmpty(S)||(T!=NULL))
{
if(T!=NULL)
{
Push(S,T);
T=T->lchild;
}
else
{
Pop(S,T);
printf("%c",T->data);
T=T->rchild;
}
}
return OK;
}
后根遍历-非递归
Status NPostRootTraverse(BiTree T)
{
SqStack S;
BiTree *p;//定义指针p，是用来指向未被访问的结点
int flag;
InitStack(S);
do
{
while(T!=NULL)//将左孩子相继入栈，找到最深处的左孩子
{
Push(S,T);
T=T->lchild;
}
p=NULL;
flag=TRUE;
while(!StackEmpty(S)&&(flag))
{
T=*(S.top-1);
if(T->rchild == p)
{
printf("%c",T->data);
S.top--;
p=T;//p指向刚访问的标记
}
else
{
T=T->rchild;//指向右子树
flag=FALSE;//设置未被访问的标记
}
}
}while(!StackEmpty(S));
return OK;
}
二叉树的层次遍历
对于一棵二叉树，从根结点开始，按从上到下，从左到右的顺序访问每一个结点，每个结点只访问一次
算法设计思路：使用顺序循环队列
1.将根结点入队
2.队不空时循环，从队列中出列一个结点p，访问它，如果有左孩子结点，将左孩子结点进队；如果有右孩子结点，将右孩子结点进队
Status DLevelOrderTraverse(BiTree T){
SqQueue Q;//创建顺序循环队列
InitQueue(Q);
EnQueue(Q,T);//根结点入队
while(!QueueEmpty(Q))
{
DeQueue(Q,T);//出队队头元素
printf("%c",T->data)
if(T->lchild != NULL )//如果左孩子存在，则入队
EnQueue(Q,T->lchild);
if(T->rchild != NULL )//如果右孩子存在，则入队
EnQueue(Q,T->rchild);
}
return OK;
}
时间空间复杂度为O(n)
二叉树遍历算法的应用
按先序遍历序列和中序遍历序列建立二叉树的二叉链表
BiTree PIcreateBiTree(char PreOrder[],char InOrder[],int PreIndex,int InIndex,int count)
//PreOrder先序遍历序列，InOrder中序遍历序列，PreIndex是先序遍历开始位置，InIndex是中序遍历的开始位置，count是结点个数
{
BiTree T;
if(count>0)//先序中序非空
{
char r =PreOrder[PreIndex];//先序遍历开头是根结点
int i = 0;
for(;i < count;i++)
{
if(r == InOrder[i+InIndex])//在中序中找到根结点
break;
}
T=(BiTree)malloc(sizeof(BiTNode));
T->data=r;
//确定根结点后
T->lchild=PICreateBiTree(PreOrder,InOrder,PreIndex+1,InIndex,i);
T->rchild=PICreateBiTree(PreOrder,InOrder,PreIndex+i+1,InIndex+i+1,count-i-1);
}
else
T=NULL;
return T;
}
复制二叉树
如果是空树，递归结束
否则，申请新结点空间。复制根结点，递归复制左子树，右子树
int Copy(BiTree T,BiTree &NewT)
{
if(T==NULL)
{
NewT=NULL;
return 0;
}
else
{
NewT=(BiTree)malloc(sizeof(BiTNode));
NewT->data=T->data;
Copy(T->lchild,NewT->lchild);
Copy(T->rchild,NewT->rchild);
}
}
计算二叉树深度
如果是空树，深度为0
否则，递归计算左子树的深度为m，递归计算右子树的深度纪委n，二叉树深度则为nm较大者+1
int Depth(BiTree T)
{
if(T==NULL)
return 0;
else if(T->lchild == NULL && T->rchild == NULL)
return 1;
else
return 1+( Depth(T->lchild) > Depth(T->rchild) ? Depth(T->lchild) : Depth(T->rchild));
}
计算二叉树结点总数
如果是空树结点个数为0
否则，结点个数等于左子树结点+右子树结点+1
int CountNode(BiTree T)
{
if(T == NULL)
return 0;
else
return CountNode(T->lchild)+CountNode(T->rchild)+1;
}
计算二叉树叶子结点总数
int CountLeafNode(BiTree T)
{
if(T == NULL)
return 0;
if(T->lchild == NULL && T->rchild == NULL)
return 1;
else
return LeafCount(T->lchild)+LeafCount(T->rchild);
}
线索二叉树
利用二叉链表中的空指针域
如果左孩子为空，则将左孩子指针域指向其前驱
如果右孩子为空，则将右孩子指针域指向后继
为了区分指针是指向孩子的还是指向前驱后继的指针，对二叉链表中每个结点增设两个标志域ltag和rtag。
typedef struct BiThrNode{
int data;
int ltag.rtag;
struct BiThrNode *lchild,rchild;
}BiThrNode,*BiThrNode;
增设了一个头结点
ltag=0.lchild指向根结点
rtag=1.rchild指向遍历序列中的最后一个结点
遍历序列中第一个结点的lchild和最后一个结点的rchild都指向头结点
树和森林
双亲链表
定义结构数组，存放树的结点，每个结点含两个域
数据域：存放结点本身信息
双亲域：指示结点的双亲位置在数组中的位置
特点：找双亲容易，找孩子难
//结点结构
typedef struct PTNode{
TElemType data;
int parent;//双亲位置域
}PTNode;
//树结构
#define MAX 100
typedef struct{
PTNode nodes[MAX];
int r,n;//根结点位置和结点个数
}
孩子链表
把每个结点的孩子结点排列起来，看成一个线性表，用单链表存储，则n个结点由n个孩子链表(叶子的孩子链表为空表)，而n个头指针又组成一个线性表，用顺序表(含n个元素的结构数组)存储
//孩子结点结构
typedef struct CTNode{
int child;//孩子下标地址
struct CTNode *next；
}*ChildPtr;//孩子结点
//双亲结点结构
typedef struct{
TElemType data;
ChildPtr fristchild;
}CTBox;//孩子链表
//树结构
typedef struct{
CTBox nodes[MAX];
int n,r;//结点数和根结点位置
}
特点：找孩子容易，找双亲难
孩子兄弟链表
使用二叉链表作为树的存储结构，链表中每个结点的两个指针域分别指向第一个孩子结点和下一个兄弟结点
typedef struct CSNode{
ElemType data;
struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;//结点类型和指向这个类型的指针
树转换成二叉树
内核：是根据使用孩子兄弟链表，将树转化为二叉树
1.加线：在兄弟之间加一条连线
2.删线：对于树的每个结点，只保留第一个孩子结点之间的连线，删去它和其他孩子结点的连线
3.旋转：转出成和二叉树差不都一样的，基本上顺时针45°
树变二叉树：兄弟连线留长子
二叉树转换成树
1.加线：若p结点是双亲结点的左孩子，则沿着p结点右分支向下所有结点和p结点的双亲结点连线
2.删线：将所有双亲结点与右孩子之间的连线删除
3.旋转
二叉树变树：左孩右右连双亲，去掉原来右孩线
森林转化二叉树
1.将各棵树分别转圜成二叉树
2.将每棵树的根结点用线相连
3.以第一棵树根结点为二叉树的根，以根结点为轴心，旋转成二叉树树※结构
森林变二叉树：树变二叉根相连
二叉树变森林
1.删线：二叉树中根结点沿着右分支的所有连线删除
2.还原：二叉树变成树
二叉树变森林：去掉全部右孩线，孤立二叉再还原
树和森林的遍历
树的遍历
先根遍历，后根遍历，层次遍历
森林的遍历
1.森林第一棵树的根结点
2.森林第一棵树的子树森林
3.森林其他树构成的森林
哈夫曼树及其应用
哈夫曼树基本概念
哈夫曼树就是一种在编码技术方面得到广泛应用的二叉树，也是一种最优二叉树
- 结点间的路径：从树中一个结点到另一个结点之间的分支构成两个结点的路径
- 结点的路径长度：两节点间路径上的分支数
- 树的路径长度：从树根到每一个结点的路径长度之和。记作TL
- 权(weight):将树中结点赋给一个有某种含义的数值，则这个数值称为该结点的权
- 结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积
- 树的带权路径长度：树中所以叶子结点的带权路径长度之和，记作WPL
哈夫曼树：最优树 带权路径长度(WPL)最短的树
哈夫曼树：最优二叉树 带权路径长度(WPL)最短的二叉树
！！！是在“度相同”的树中比较而得出的结果！！！
1.哈夫曼树不唯一
2.权越大的叶子离根结点越近(位高权重)
哈夫曼树的构造算法
贪心算法思想：构造哈夫曼树时首先选择权值较小的叶子结点
哈夫曼算法（构造哈夫曼树的方法）
1.初始化操作：由已知给定的n个权值，构造一个有n棵二叉树所构成的森林，其中每棵二叉树只有一个根结点，并且每个根结点的权值分别为已知的给的权值
2.选取与组合操作：在二叉树森林F中选取根结点的权值最小和次小的两棵二叉树，分别把他们作为左子树和右子树去构造一棵新的二叉树，新的树的根结点权值为左子树根结点和右子树根结点权值之和
3.删除与归并操作：将新二叉树的左右子树两棵二叉树从森林F中删除，并将新产生的二叉树加入到森林F中
4.重复2和3，知道森林F里面只有一棵二叉树为止，这棵树就是哈夫曼树
说人话版：1.构造森林全是根；2.选用两小造新树；3.删除两小添新人；4.重复2，3剩单根
特点1： 哈夫曼树的结点的度数为0或2，没有度为1的结点
特点2： 包含n个叶子结点的哈夫曼树共有2n-1（n+n-1：包含n棵树的森林要经过n-1次合并才能形成哈夫曼树，共产生n-1个新结点）个结点
哈夫曼树构造算法的实现
采用顺序存储结构-一维结构数组
- 结点类型定义
typedef struct HTNode{
int weight;//权值域
ElemType data;
int parent,lchild,rchild;
}HTNode,*HuffmanTree;
- 哈夫曼树构造算法的实现
初始化HT
输入初始n个叶子结点，置HT[1…n]的权值(weight)
void CreatHuffmanTree(HuffmanTree HT,int n)
{
if(n <= 1)
return;
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0单元未使用，HT[m]表示根结点
for(i=1;i <= m;i++)
{
HT[i].lchild=0;
HT[i].rchild=0;
HT[i].parent=0;
}
for(i=1;i <= n;i++)
{
scanf("%c", &HT[i]->weight);//输入前n个元素的weight值
}
//初始化完成，开始合并
for(i=n+1;i <= m;i++)
{
SelectMin(HT,i-1,p1,p2);
HT[p1].parent=i;
HT[p2].parent=i;//表示在F删除p1，p2
HT[i].lchild=p1;
HT[i].rchild=p2;//p1，p2，作为i的左右孩子
HT[i].weight=HT[p1].weight+HT[p2].weight;//i的权值为左右孩子权值之和
}
}
void SelectMin(HuffmanTree HT,int i,int &p1,int &p2)
{
long min1=99999;
long min2=99999;
int j;
for(j=1;j <= i;j++)
{
if(HT[j].parent == 0)
if(min1>HT[j].weight)
{
min1=HT[j].weight;
p1=j;
}
}
for(j=1;j <= i;j++)
{
if(HT[j].parent == 0)
if(min2>HT[j].weight)
{
min2=HT[j].weight;
p1=j;
}
}
}
哈夫曼编码
1.统计字符集中每个字符在电文中出现的平均概率（概率越大，要求编码越短）
2.利用哈夫曼树的特点：权越大的叶子离根越近；==将每个字符的概率值作为权值，构造哈夫曼树。==概率越大的结点，路径越短。
3.在哈夫曼树的每个分支上标记0或1：结点的做分支标0，右分支标1；把从根到每个叶子的路径上的标号连接起来，作为该叶子代表的字符的编码
说人话： 一个字符集中找出各个字符出现的频率，构造哈夫曼树，然后左分支0，右分支1，从根结点到叶子结点的路径的编码就是哈夫曼编码
- 两个问题
1.为什么哈夫曼编码能够保证是前缀编码？
因为没有一片叶子结点是另一个叶子结点的祖先，所以每个叶子结点的编码就不可能是其他叶子结点编码的前缀
2.为什么哈夫曼树编码能够保证字符编码总长最短
因为哈夫曼树的带权路径长度最短，故字符编码总长度最短
性质1:哈夫曼编码是前缀码
性质2：哈夫曼编码是最优前缀码
哈夫曼编码的算法实现
void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
.....
//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中，HC分配n个字符编码的头指针矢量，cd分配临时存放编码的动态数组空间
for(i=1;i <= n;++i)//逐个字符求哈夫曼编码
{
start=n+1;c=i;f=HT[i].parent;
while(f!=0)
{
--start；
if(HT[f].lchild == c)
cd[start]='0';
else
cd[start]='1';
c=f;f=HT[f].parent;
}
...//为第i个字符分配空间，把求得的编码从临时空间存到HC中
}
}
p; 2.为什么哈夫曼树编码能够保证字符编码总长最短
因为哈夫曼树的带权路径长度最短，故字符编码总长度最短
性质1:哈夫曼编码是前缀码
性质2：哈夫曼编码是最优前缀码
哈夫曼编码的算法实现
void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
.....
//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中，HC分配n个字符编码的头指针矢量，cd分配临时存放编码的动态数组空间
for(i=1;i <= n;++i)//逐个字符求哈夫曼编码
{
start=n+1;c=i;f=HT[i].parent;
while(f!=0)
{
--start；
if(HT[f].lchild == c)
cd[start]='0';
else
cd[start]='1';
c=f;f=HT[f].parent;
}
...//为第i个字符分配空间，把求得的编码从临时空间存到HC中
}
}
讲的不详细（都是伪代码），如果不懂，得去找资料看（哈夫曼编码）
