《大话数据结构》第六章 树
《大话数据结构 》
- 第六章 树
- 树的存储结构表示法
- 二叉树
- 顺序存储二叉树
- 顺序存储二叉树测试案例
- 二叉链表
- 二叉链表测试案例
- 线索二叉树
- 线索二叉树链测试案例
- 郝夫曼树与郝夫曼编码
第六章 树
树的定义：树（Tree）是n(n>=0)个结点的有限集。线性表是一对一的结构，而树则是一对多的结构。
条件：(1) 有且仅有一个根结点。(2) 子树的个数没有限制，但一定互不相交。
树的结点包含一个数据元素以及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点(Leaf)或者终端结点。度不为0的结点称为非终端结点或分支结点。除根结点之外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。
点的层次(Level)从根开始定义起，根为第一层，根的孩子为第二层，树中结点的最大层次称为树的深度(Depth)或者高度。
树的存储结构表示法
双亲表示法：每个结点中，附设一个指示器指示其双亲结点到链表中的位置。也就是说，每个结点除了知道自己是谁以外，还知道它的双亲在哪里。结点结构：其中data是数据域，存储结点的数据信息，而parent是指针域，存储该结点的双亲在数组中的下标。由于根结点没有双亲，所以我们约定根结点的设置域为-1，这就意味者，所有的根结点都存有他双亲的位置。双亲表示法默认了所有结点的位置标号按从上到下、从左到右依次增加，第一行是0，第二行从左到右是1、2。
双亲表示法结点PTNode的结构：
| int data | int parent |
|---|
树的结构：
| PTNode nodes[MAX_TREE_SIZE] | int r,n；根的位置和结点数 |
|---|
数据结构：
#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;
孩子表示法的改进：孩子表示法不能像双亲表示法那样，双亲表示法任何一个结点肯定是只有1个父结点，用int parent存储父亲位置即可，孩子表示法如果用这种方式int child; int child1; …你不知道每个结点到底有几个子节点，即每个结点的度是不一样的。倘若安装树的深度来确定结点最大度n，然后每个结点设置n个变量指向子节点，显然是对资源的浪费。倘若每个结点中增加一个变量int degree; degree表示该结点的度域，存储该结点的孩子结点个数，克服了空间的浪费，这样在运算上需要维护结点度的数值，运算上会带来时间上的损耗。
因此，对孩子表示法设计的结构进行改进，设计两种结构，ChildPtr孩子结点和表头结点ChildTableNode，表头数组的表头结点p存放每放该结点的值和其第一个孩子结点指针。第一个孩子结点会存放它的下标位置，并指向p的下一个孩子结点，若没有则为null。树的结构由所有的表头结点（ChildTableNode[]）与表头结点存储的值组成。每个结点的位置标号还是按从上到下、从左到右依次增加。
ChildTableNode 表头结点：
| int data | ChildPtr firstChild |
|---|
孩子结点ChildPtr：
| int child 孩子结点的下标 | ChildPtr next |
|---|
树的结构：
| ChildTableNode nodes[MAX_TREE_SIZE] | int r,n；根的位置和结点数 |
|---|
主要还是要记住下面的图：
改进的孩子表示法代码：注意struct的定义结构体用法，注意typedef将结构体取别名，用结构体指针表示，typedef 结构体取别名用法。
#define MAX_TREE_SIZE 100;
struct
{
int data;
ChildPtr firstChild;
}ChildTableNode;
#typedef struct Child{
int child; //孩子结点下标位置
Child *next;
} *ChildPtr;
typedef struct
{
ChildTableNode[MAX_SIZE_TREE];
int r,n; //根结点位置 ，结点个数
}Tree;
孩子兄弟表示法：任意一个结点如果它的右兄弟存在，那么右兄弟肯定是唯一的。
Child结点结构：
| int data | Child *firstChild | Child *rightChild |
|---|
树：
| int data | Child *firstChild | Child *rightChild |
|---|
结构体定义代码：
typedef struct ChildNode
{
int data;
struct ChildNode *firstChild,*rightChild;
}ChildNode,*Tree;
简单使用：
二叉树
特点：每个结点最多两颗子树，每个结点的子树左右是分顺序，即使只有一颗子树也要区分是左子树还是右子树。
特殊的二叉树：左斜树(所有的结点只有左子树)、右斜树(所有的结点只有右左树)、满二叉树(所有的分支结点只有左右子树，并且所有的叶子都在同一层)、完全二叉树(除了最后一层每一层结点都达到最大值)。满二叉树一定是一颗完全二叉树，但是完全二叉树不一定是满的。
二叉树的性质： ,
- 在二叉树的第 i 层上最多有2i-1个结点（i>=1）.
- 深度为k的二叉树至多有2i-1个结点(i≥1)
- 对任何一棵二叉树T，其叶子结点数=度为2的结点数+1
- 具有n个结点的完全二叉树的深度不大于log2nlog2n+1的最大整数
- 如果对一棵有n个结点的完全二叉树的结点按层序编号（每层从左到右），对任一结点i(1≤i≤n)有
如果i=1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是结点i/2
如果2i>n，则结点i无左孩子（结点i为叶子结点）；否则其左孩子是结点2i
如果2i+1>n，则结点i无右孩子；否则其右孩子是结点2i+1
顺序存储二叉树
顺序存储结构：只适用于完全二叉树。若某个结点不存在，对应标号的结点值设置为倒V。若深度为k的右斜树，只有k个结点，但是却要分配2的k次方-1个存储空间，太浪费。
完全二叉树采用顺序存储的方式，你可以看出优势。
顺序存储二叉树的数据结构：使用前提：完全二叉树。 SqBiTree T; 用一个MAX_TREE_SIZE大小的数组即可表示顺序二叉树。
#define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */
typedef int TElemType; /* 树结点的数据类型，目前暂定为整型 */
typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根结点 */
TElemType Nil=0; /* 设整型以0为空 */
typedef struct
{
int level,order; /* 结点的层,本层序号(按满二叉树计算) */
}Position;
顺序存储二叉树
- 判断是否为空：判断根结点T[0]是否为Nil，假定Nil为0 是空。
- 求树的深度：先遍历看T[i]是否出现Nil，若出现空，跳出遍历，j = 0;遍历j的2次方是否大于i。若大于，跳出遍历深度为j-1。
- 给树T的某个位置p(树的层数，该层的序号)赋值e。先通过p获得T[]下标i，给叶子赋非空值但双亲为空if(value!=Nil&&T[(i+1)/2-1]==Nil) ，或者给双亲赋空值但有叶子（不空）if(value= =Nil&&(T[i2+1]!=Nil||T[i2+2]!=Nil))情形下 return ERROR;
- 先序遍历：
void PreTraverse(SqBiTree T,int e)
{
visit(T[e]);
if(T[2e+1]!=Nil) / 左子树不空 /
PreTraverse(T,2e+1);
if(T[2e+2]!=Nil) / 右子树不空 /
PreTraverse(T,2e+2);
}
Status PreOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) /* 树不空 /
PreTraverse(T,0);
printf("\n");
return OK;
}
中序遍历：
void InTraverse(SqBiTree T,int e)
{
if(T[2e+1]!=Nil) /* 左子树不空 /
InTraverse(T,2e+1);
visit(T[e]);
if(T[2e+2]!=Nil) / 右子树不空 /
InTraverse(T,2e+2);
}
/* 操作结果: 中序遍历T。 /
Status InOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) / 树不空 /
InTraverse(T,0);
printf("\n");
return OK;
}
后序遍历：
/ PostOrderTraverse()调用 /
void PostTraverse(SqBiTree T,int e)
{
if(T[2e+1]!=Nil) /* 左子树不空 /
PostTraverse(T,2e+1);
if(T[2e+2]!=Nil) / 右子树不空 /
PostTraverse(T,2e+2);
visit(T[e]);
}
/* 操作结果: 后序遍历T。 /
Status PostOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) / 树不空 */
PostTraverse(T,0);
printf("\n");
return OK;
}
顺序存储二叉树测试案例
10个结点的顺序树，第一层 根结点为1，第二层 2 、3，第三层 4、5、6 ，第四层 7、8、9、10。
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
#define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType; /* 树结点的数据类型，目前暂定为整型 */
typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根结点 */
typedef struct
{
int level,order; /* 结点的层,本层序号(按满二叉树计算) */
}Position;
TElemType Nil=0; /* 设整型以0为空 */
Status visit(TElemType c)
{
printf("%d ",c);
return OK;
}
/* 构造空二叉树T。因为T是固定数组，不会改变，故不需要& */
Status InitBiTree(SqBiTree T)
{
int i;
for(i=0;i<MAX_TREE_SIZE;i++)
T[i]=Nil; /* 初值为空 */
return OK;
}
/* 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T */
Status CreateBiTree(SqBiTree T)
{
int i=0;
printf("请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数≤%d:\n",MAX_TREE_SIZE);
while(i<10)
{
T[i]=i+1;
i++;
}
while(i<MAX_TREE_SIZE) //设整型以0为空
{
T[i]=Nil; /* 将空赋值给T的后面的结点 */
i++;
}
return OK;
}
#define ClearBiTree InitBiTree /* 在顺序存储结构中，两函数完全一样 */
/* 初始条件: 二叉树T存在 */
/* 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */
Status BiTreeEmpty(SqBiTree T)
{
if(T[0]==Nil) /* 根结点为空,则树空 */
return TRUE;
else
return FALSE;
}
/* 初始条件: 二叉树T存在。操作结果: 返回T的深度 */
int BiTreeDepth(SqBiTree T)
{
int i,j=-1;
for(i=MAX_TREE_SIZE-1;i>=0;i--) /* 找到最后一个结点 */
if(T[i]!=Nil)
break;
i++;
do
j++;
while(i>=powl(2,j));/* 计算2的j次幂。 */
return j;
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 当T不空,用e返回T的根,返回OK;否则返回ERROR,e无定义 */
Status Root(SqBiTree T,TElemType *e)
{
if(BiTreeEmpty(T)) /* T空 */
return ERROR;
else
{
*e=T[0];
return OK;
}
}
/* 初始条件: 二叉树T存在,e是T中某个结点(的位置) */
/* 操作结果: 返回处于位置e(层,本层序号)的结点的值 */
TElemType Value(SqBiTree T,Position e)
{
return T[(int)powl(2,e.level-1)+e.order-2];
}
/* 初始条件: 二叉树T存在,e是T中某个结点(的位置) */
/* 操作结果: 给处于位置e(层,本层序号)的结点赋新值value */
Status Assign(SqBiTree T,Position e,TElemType value)
{
int i=(int)powl(2,e.level-1)+e.order-2; /* 将层、本层序号转为矩阵的序号 */
if(value!=Nil&&T[(i+1)/2-1]==Nil) /* 给叶子赋非空值但双亲为空 */
return ERROR;
else if(value==Nil&&(T[i*2+1]!=Nil||T[i*2+2]!=Nil)) /* 给双亲赋空值但有叶子（不空） */
return ERROR;
T[i]=value;
return OK;
}
/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 若e是T的非根结点,则返回它的双亲,否则返回＂空＂ */
TElemType Parent(SqBiTree T,TElemType e)
{
int i;
if(T[0]==Nil) /* 空树 */
return Nil;
for(i=1;i<=MAX_TREE_SIZE-1;i++)
if(T[i]==e) /* 找到e */
return T[(i+1)/2-1];
return Nil; /* 没找到e */
}
/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的左孩子。若e无左孩子,则返回＂空＂ */
TElemType LeftChild(SqBiTree T,TElemType e)
{
int i;
if(T[0]==Nil) /* 空树 */
return Nil;
for(i=0;i<=MAX_TREE_SIZE-1;i++)
if(T[i]==e) /* 找到e */
return T[i*2+1];
return Nil; /* 没找到e */
}
/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的右孩子。若e无右孩子,则返回＂空＂ */
TElemType RightChild(SqBiTree T,TElemType e)
{
int i;
if(T[0]==Nil) /* 空树 */
return Nil;
for(i=0;i<=MAX_TREE_SIZE-1;i++)
if(T[i]==e) /* 找到e */
return T[i*2+2];
return Nil; /* 没找到e */
}
/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂ */
TElemType LeftSibling(SqBiTree T,TElemType e)
{
int i;
if(T[0]==Nil) /* 空树 */
return Nil;
for(i=1;i<=MAX_TREE_SIZE-1;i++)
if(T[i]==e&&i%2==0) /* 找到e且其序号为偶数(是右孩子) */
return T[i-1];
return Nil; /* 没找到e */
}
/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂ */
TElemType RightSibling(SqBiTree T,TElemType e)
{
int i;
if(T[0]==Nil) /* 空树 */
return Nil;
for(i=1;i<=MAX_TREE_SIZE-1;i++)
if(T[i]==e&&i%2) /* 找到e且其序号为奇数(是左孩子) */
return T[i+1];
return Nil; /* 没找到e */
}
/* PreOrderTraverse()调用 */
void PreTraverse(SqBiTree T,int e)
{
visit(T[e]);
if(T[2*e+1]!=Nil) /* 左子树不空 */
PreTraverse(T,2*e+1);
if(T[2*e+2]!=Nil) /* 右子树不空 */
PreTraverse(T,2*e+2);
}
/* 初始条件: 二叉树存在 */
/* 操作结果: 先序遍历T。 */
Status PreOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) /* 树不空 */
PreTraverse(T,0);
printf("\n");
return OK;
}
/* InOrderTraverse()调用 */
void InTraverse(SqBiTree T,int e)
{
if(T[2*e+1]!=Nil) /* 左子树不空 */
InTraverse(T,2*e+1);
visit(T[e]);
if(T[2*e+2]!=Nil) /* 右子树不空 */
InTraverse(T,2*e+2);
}
/* 初始条件: 二叉树存在 */
/* 操作结果: 中序遍历T。 */
Status InOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) /* 树不空 */
InTraverse(T,0);
printf("\n");
return OK;
}
/* PostOrderTraverse()调用 */
void PostTraverse(SqBiTree T,int e)
{
if(T[2*e+1]!=Nil) /* 左子树不空 */
PostTraverse(T,2*e+1);
if(T[2*e+2]!=Nil) /* 右子树不空 */
PostTraverse(T,2*e+2);
visit(T[e]);
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序遍历T。 */
Status PostOrderTraverse(SqBiTree T)
{
if(!BiTreeEmpty(T)) /* 树不空 */
PostTraverse(T,0);
printf("\n");
return OK;
}
/* 层序遍历二叉树 */
void LevelOrderTraverse(SqBiTree T)
{
int i=MAX_TREE_SIZE-1,j;
while(T[i]==Nil)
i--; /* 找到最后一个非空结点的序号 */
for(j=0;j<=i;j++) /* 从根结点起,按层序遍历二叉树 */
if(T[j]!=Nil)
visit(T[j]); /* 只遍历非空的结点 */
printf("\n");
}
/* 逐层、按本层序号输出二叉树 */
void Print(SqBiTree T)
{
int j,k;
Position p;
TElemType e;
for(j=1;j<=BiTreeDepth(T);j++)
{
printf("第%d层: ",j);
for(k=1;k<=powl(2,j-1);k++)
{
p.level=j;
p.order=k;
e=Value(T,p);
if(e!=Nil)
printf("%d:%d ",k,e);
}
printf("\n");
}
}
int main()
{
Status i;
Position p;
TElemType e;
SqBiTree T;
InitBiTree(T);
CreateBiTree(T);
printf("建立二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
i=Root(T,&e);
if(i)
printf("二叉树的根为：%d\n",e);
else
printf("树空，无根\n");
printf("层序遍历二叉树:\n");
LevelOrderTraverse(T);
printf("前序遍历二叉树:\n");
PreOrderTraverse(T);
printf("中序遍历二叉树:\n");
InOrderTraverse(T);
printf("后序遍历二叉树:\n");
PostOrderTraverse(T);
printf("修改结点的层号3本层序号2。");
p.level=3;
p.order=2;
e=Value(T,p);
printf("待修改结点的原值为%d请输入新值:50 ",e);
e=50;
Assign(T,p,e);
printf("前序遍历二叉树:\n");
PreOrderTraverse(T);
printf("结点%d的双亲为%d,左右孩子分别为",e,Parent(T,e));
printf("%d,%d,左右兄弟分别为",LeftChild(T,e),RightChild(T,e));
printf("%d,%d\n",LeftSibling(T,e),RightSibling(T,e));
ClearBiTree(T);
printf("清除二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
i=Root(T,&e);
if(i)
printf("二叉树的根为：%d\n",e);
else
printf("树空，无根\n");
return 0;
}
运行结果：
二叉链表
数据结构：
BiTNode结点结构：
| int data | BiTNode *lchild | BiTNode *rchild |
|---|
结点代码：
typedef struct BiTNode /* 结点结构 */
{
TElemType data; /* 结点数据 */
struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;
初始化并创建树：通过递归创建树，简直无敌。先设计一条str字符串 ABDH#K###E##CFI###G#J##，递归对字符串str进行判断，若遇到#字符就返回，否则CreateBiTree(&((*T)->lchild)); 或者 CreateBiTree(&((T)->rchild)); / 构造右子树 */，将树的左结点或者右结点当做递归函数的参数。
/* 用于构造二叉树********************************** */
int index=1;
typedef char String[24]; /* 0号单元存放串的长度 */
String str;
Status StrAssign(String T,char *chars)
{
int i;
if(strlen(chars)>MAXSIZE)
return ERROR;
else
{
T[0]=strlen(chars);
for(i=1;i<=T[0];i++)
T[i]=*(chars+i-1);
return OK;
}
}
/* 按前序输入二叉树中结点的值（一个字符） */
/* #表示空树，构造二叉链表表示二叉树T。 */
void CreateBiTree(BiTree *T)
{
TElemType ch;
ch=str[index++];
if(ch=='#')
*T=NULL;
else
{
*T=(BiTree)malloc(sizeof(BiTNode));
if(!*T)
exit(OVERFLOW);
(*T)->data=ch; /* 生成根结点 */
CreateBiTree(&((*T)->lchild)); /* 构造左子树 */
CreateBiTree(&((*T)->rchild)); /* 构造右子树 */
}
}
void main{
BiTree T;
*T = NULL;
StrAssign(str,"ABDH##I##EJ###CF##G##");
CreateBiTree(&T);
}
字是真的丑啊
前序遍历、中序遍历：
二叉链表测试案例
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
/* 用于构造二叉树********************************** */
int index=1;
typedef char String[24]; /* 0号单元存放串的长度 */
String str;
Status StrAssign(String T,char *chars)
{
int i;
if(strlen(chars)>MAXSIZE)
return ERROR;
else
{
T[0]=strlen(chars);
for(i=1;i<=T[0];i++)
T[i]=*(chars+i-1);
return OK;
}
}
/* ************************************************ */
typedef char TElemType;
TElemType Nil=' '; /* 字符型以空格符为空 */
Status visit(TElemType e)
{
printf("%c ",e);
return OK;
}
typedef struct BiTNode /* 结点结构 */
{
TElemType data; /* 结点数据 */
struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;
/* 构造空二叉树T */
Status InitBiTree(BiTree *T)
{
*T=NULL;
return OK;
}
/* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
void DestroyBiTree(BiTree *T)
{
if(*T)
{
if((*T)->lchild) /* 有左孩子 */
DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
if((*T)->rchild) /* 有右孩子 */
DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
free(*T); /* 释放根结点 */
*T=NULL; /* 空指针赋0 */
}
}
/* 按前序输入二叉树中结点的值（一个字符） */
/* #表示空树，构造二叉链表表示二叉树T。 */
void CreateBiTree(BiTree *T)
{
TElemType ch;
ch=str[index++];
if(ch=='#')
*T=NULL;
else
{
*T=(BiTree)malloc(sizeof(BiTNode));
if(!*T)
exit(OVERFLOW);
(*T)->data=ch; /* 生成根结点 */
CreateBiTree(&((*T)->lchild)); /* 构造左子树 */
CreateBiTree(&((*T)->rchild)); /* 构造右子树 */
}
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */
Status BiTreeEmpty(BiTree T)
{
if(T)
return FALSE;
else
return TRUE;
}
#define ClearBiTree DestroyBiTree
/* 初始条件: 二叉树T存在。操作结果: 返回T的深度 */
int BiTreeDepth(BiTree T)
{
int i,j;
if(!T)
return 0;
if(T->lchild)
i=BiTreeDepth(T->lchild);
else
i=0;
if(T->rchild)
j=BiTreeDepth(T->rchild);
else
j=0;
return i>j?i+1:j+1;
}
/* 初始条件: 二叉树T存在。操作结果: 返回T的根 */
TElemType Root(BiTree T)
{
if(BiTreeEmpty(T))
return Nil;
else
return T->data;
}
/* 初始条件: 二叉树T存在，p指向T中某个结点 */
/* 操作结果: 返回p所指结点的值 */
TElemType Value(BiTree p)
{
return p->data;
}
/* 给p所指结点赋值为value */
void Assign(BiTree p,TElemType value)
{
p->data=value;
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 前序递归遍历T */
void PreOrderTraverse(BiTree T)
{
if(T==NULL)
return;
printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 中序递归遍历T */
void InOrderTraverse(BiTree T)
{
if(T==NULL)
return;
InOrderTraverse(T->lchild); /* 中序遍历左子树 */
printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}
/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序递归遍历T */
void PostOrderTraverse(BiTree T)
{
if(T==NULL)
return;
PostOrderTraverse(T->lchild); /* 先后序遍历左子树 */
PostOrderTraverse(T->rchild); /* 再后序遍历右子树 */
printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}
int main()
{
int i;
BiTree T;
TElemType e1;
InitBiTree(&T);
StrAssign(str,"ABDH##I##EJ###CF##G##");
CreateBiTree(&T);
printf("构造空二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);
printf("二叉树的根为: %c\n",e1);
printf("\n前序遍历二叉树:");
PreOrderTraverse(T);
printf("\n中序遍历二叉树:");
InOrderTraverse(T);
printf("\n后序遍历二叉树:");
PostOrderTraverse(T);
ClearBiTree(&T);
printf("\n清除二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
i=Root(T);
if(!i)
printf("树空，无根\n");
return 0;
}
运行结果：
线索二叉树
在二叉树链的例子中，我们前序遍历一遍二叉树后得到ABDHKECFIGJ，此时我们才知道I的前驱是F，后继是G，但是必须要先遍历一遍才知道。二叉树链优点在于可以知道左右子树是谁，但是无法直接知道前驱后继。因此我们在二叉树链中加入指向前驱和后继的指针，加上的指针也称为线索，相应的二叉树链表称为线索二叉树。每个结点都只有一个直接前驱和一个直接后继。（除区头尾两个结点）
结点的数据结构：
typedef enum {Link,Thread} PointerTag; /* Link==0表示指向左右孩子指针, */
/* Thread==1表示指向前驱或后继的线索 */
typedef struct BiThrNode /* 二叉线索存储结点结构 */
{
TElemType data; /* 结点数据 */
struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
PointerTag LTag;
PointerTag RTag; /* 左右标志 */
} BiThrNode, *BiThrTree;
树的创建：
typedef char TElemType;
typedef enum {Link,Thread} PointerTag; /* Link==0表示指向左右孩子指针, */
/* Thread==1表示指向前驱或后继的线索 */
typedef struct BiThrNode /* 二叉线索存储结点结构 */
{
TElemType data; /* 结点数据 */
struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
PointerTag LTag;
PointerTag RTag; /* 左右标志 */
} BiThrNode, *BiThrTree;
TElemType Nil='#'; /* 字符型以空格符为空 */
/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{
TElemType h;
scanf("%c",&h);
if(h==Nil)
*T=NULL;
else
{
*T=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*T)
exit(OVERFLOW);
(*T)->data=h; /* 生成根结点(前序) */
CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
if((*T)->lchild) /* 有左孩子 */
(*T)->LTag=Link;
CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
if((*T)->rchild) /* 有右孩子 */
(*T)->RTag=Link;
}
return OK;
}
int main()
{
BiThrTree H,T;
printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
CreateBiThrTree(&T); /* 按前序产生二叉树 */
}
通常规定：对某一结点p，若无左子树，将p->lchild指向前驱结点；若无右子树，将p->rchild指向后继结点，不过由于此时p的后继还没访问到，因此只能对p的前驱结点pre进行右指针判断，如果pre的右指针为空，则p就是pre的后继pre->rchild = p。
核心的遍历代码：
/* 中序遍历进行中序线索化 */
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); /* 递归右子树线索化 */
}
}
中序遍历解析：
线索二叉树链测试案例
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef char TElemType;
typedef enum {Link,Thread} PointerTag; /* Link==0表示指向左右孩子指针, */
/* Thread==1表示指向前驱或后继的线索 */
typedef struct BiThrNode /* 二叉线索存储结点结构 */
{
TElemType data; /* 结点数据 */
struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
PointerTag LTag;
PointerTag RTag; /* 左右标志 */
} BiThrNode, *BiThrTree;
TElemType Nil='#'; /* 字符型以空格符为空 */
Status visit(TElemType e)
{
printf("%c ",e);
return OK;
}
/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{
TElemType h;
scanf("%c",&h);
if(h==Nil)
*T=NULL;
else
{
*T=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*T)
exit(OVERFLOW);
(*T)->data=h; /* 生成根结点(前序) */
CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
if((*T)->lchild) /* 有左孩子 */
(*T)->LTag=Link;
CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
if((*T)->rchild) /* 有右孩子 */
(*T)->RTag=Link;
}
return OK;
}
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,并将其中序线索化,Thrt指向头结点 */
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{
*Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*Thrt)
exit(OVERFLOW);
(*Thrt)->LTag=Link; /* 建头结点 */
(*Thrt)->RTag=Thread;
(*Thrt)->rchild=(*Thrt); /* 右指针回指 */
if(!T) /* 若二叉树空,则左指针回指 */
(*Thrt)->lchild=*Thrt;
else
{
(*Thrt)->lchild=T;
pre=(*Thrt);
InThreading(T); /* 中序遍历进行中序线索化 */
pre->rchild=*Thrt;
pre->RTag=Thread; /* 最后一个结点线索化 */
(*Thrt)->rchild=pre;
}
return OK;
}
/* 中序遍历二叉线索树T(头结点)的非递归算法 */
Status InOrderTraverse_Thr(BiThrTree T)
{
BiThrTree p;
p=T->lchild; /* p指向根结点 */
while(p!=T)
{ /* 空树或遍历结束时,p==T */
while(p->LTag==Link)
p=p->lchild;
if(!visit(p->data)) /* 访问其左子树为空的结点 */
return ERROR;
while(p->RTag==Thread&&p->rchild!=T)
{
p=p->rchild;
visit(p->data); /* 访问后继结点 */
}
p=p->rchild;
}
return OK;
}
int main()
{
BiThrTree H,T;
printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
CreateBiThrTree(&T); /* 按前序产生二叉树 */
InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */
printf("中序遍历(输出)二叉线索树:\n");
InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
printf("\n");
return 0;
}
运行结果：
郝夫曼树与郝夫曼编码
哈夫曼树（霍夫曼树）又称为最优树。
路径和路径长度：例如下图左图，二叉树a的树路径长度为1+1+2+2+3+3+4+4 = 20，树b的路径长度1+2+3+3+2+1+2+2 = 16。
结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。
树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。
郝夫曼编码：
