第 5 章 树与二叉树
5.1 树
树（tree） 是n（n>=0）个结点的有限集。n=0时称为空树。在任何一棵非空树中：
（1）有且只有一个特定的称为 根（root） 的结点。
（2）当n>1时，其余结点可分为m（m>0）个 互不相交 的有限集，其中每一个集合又是一棵树，并且成为 根的子树（subtree）。
树是一种一对多的结构。
5.2 二叉树
5.2.1 二叉树的定义
二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点 。
如果二叉树中除了叶子结点，每个结点的度都为 2，则此二叉树称为满二叉树。
如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。
5.2.2 二叉树的顺序存储结构
二叉树的顺序存储结构如下所示：
#define NODENUM 7 //二叉树中的结点数量
#define ElemType int //结点值的类型
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[MaxSize];存储二叉树如下所示：
#include <stdio.h>
#define NODENUM 7
#define ElemType int
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[NODENUM];
//存储二叉树
void InitBiTree(BiTree T) {
ElemType node;
int i = 0;
printf("按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:");
while (scanf("%d", &node))
{
T[i] = node;
i++;
}
}
//查找某个结点的双亲结点的值
ElemType Parent(BiTree T, ElemType e) {
int i;
if (T[0] == 0) {
printf("存储的是一棵空树\n");
}
else
{
if (T[0] == e) {
printf("当前结点是根节点，没有双亲结点\n");
return 0;
}
for (i = 1; i < NODENUM; i++) {
if (T[i] == e) {
//借助各个结点的标号(数组下标+1)，找到双亲结点的存储位置
return T[(i + 1) / 2 - 1];
}
}
printf("二叉树中没有指定结点\n");
}
return -1;
}
//查找某个结点的左孩子结点的值
ElemType LeftChild(BiTree T, ElemType e) {
int i;
if (T[0] == 0) {
printf("存储的是一棵空树\n");
}
else
{
for (i = 1; i < NODENUM; i++) {
if (T[i] == e) {
//借助各个结点的标号(数组下标+1)，找到左孩子结点的存储位置
if (((i + 1) * 2 < NODENUM) && (T[(i + 1) * 2 - 1] != 0)) {
return T[(i + 1) * 2 - 1];
}
else
{
printf("当前结点没有左孩子\n");
return 0;
}
}
}
printf("二叉树中没有指定结点\n");
}
return -1;
}
//查找某个结点的右孩子结点的值
ElemType RightChild(BiTree T, ElemType e) {
int i;
if (T[0] == 0) {
printf("存储的是一棵空树\n");
}
else
{
for (i = 1; i < NODENUM; i++) {
if (T[i] == e) {
//借助各个结点的标号(数组下标+1)，找到左孩子结点的存储位置
if (((i + 1) * 2 + 1 < NODENUM) && (T[(i + 1) * 2] != 0)) {
return T[(i + 1) * 2];
}
else
{
printf("当前结点没有右孩子\n");
return 0;
}
}
}
printf("二叉树中没有指定结点\n");
}
return -1;
}
int main() {
int res;
BiTree T = { 0 };
InitBiTree(T);
res = Parent(T, 3);
if (res != 0 && res != -1) {
printf("结点3的双亲结点的值为 %d\n", res);
}
res = LeftChild(T, 2);
if (res != 0 && res != -1) {
printf("结点2的左孩子的值为 %d\n", res);
}
res = RightChild(T, 2);
if (res != 0 && res != -1) {
printf("结点2的右孩子的值为 %d\n", res);
}
return 0;
}5.2.3 二叉树的链式存储结构
表示节点结构的代码如下所示：
typedef struct BiTNode{
TElemType data;//数据域
struct BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;使用链表存储二叉树：
#include <stdio.h>
#include <stdlib.h>
#define TElemType int
typedef struct BiTNode {
TElemType data;//数据域
struct BiTNode* lchild, * rchild;//左右孩子指针
}BiTNode, * BiTree;
void CreateBiTree(BiTree* T) {
*T = (BiTNode*)malloc(sizeof(BiTNode));
(*T)->data = 1;
(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
(*T)->lchild->data = 2;
(*T)->rchild = (BiTNode*)malloc(sizeof(BiTNode));
(*T)->rchild->data = 3;
(*T)->rchild->lchild = NULL;
(*T)->rchild->rchild = NULL;
(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
(*T)->lchild->lchild->data = 4;
(*T)->lchild->rchild = NULL;
(*T)->lchild->lchild->lchild = NULL;
(*T)->lchild->lchild->rchild = NULL;
}
//后序遍历二叉树，释放树占用的内存
void DestroyBiTree(BiTree T) {
if (T) {
DestroyBiTree(T->lchild);//销毁左孩子
DestroyBiTree(T->rchild);//销毁右孩子
free(T);//释放结点占用的内存
}
}
int main() {
BiTree Tree;
CreateBiTree(&Tree);
printf("根节点的左孩子结点为：%d\n", Tree->lchild->data);
printf("根节点的右孩子结点为：%d\n", Tree->rchild->data);
DestroyBiTree(Tree);
return 0;
}5.3 二叉树的遍历
5.3.1 二叉树的先序遍历
所谓先序遍历二叉树，指的是从根结点出发，按照以下步骤访问二叉树的每个结点：
（1）访问当前结点。
（2）进入当前结点的左子树，以同样的步骤遍历左子树中的结点。
（3）遍历完当前结点的左子树后，再进入它的右子树，以同样的步骤遍历右子树中的结点。
对于顺序表存储的二叉树，递归实现先序遍历二叉树的 代码如下：
void PreOrderTraverse(BiTree T, int p_node) {
//根节点的值不为 0，证明二叉树存在
if (T[p_node]) {
printf("%d ", T[p_node]);
//先序遍历左子树
if ((2 * p_node + 1 < NODENUM) && (T[2 * p_node + 1] != 0)) {
PreOrderTraverse(T, 2 * p_node + 1);
}
//最后先序遍历右子树
if ((2 * p_node + 2 < NODENUM) && (T[2 * p_node + 2] != 0)) {
PreOrderTraverse(T, 2 * p_node + 2);
}
}
}对于链表存储的二叉树，递归实现先序遍历二叉树的代码如下所示：
void PreOrderTraverse(BiTree T) {
//如果二叉树存在，则遍历二叉树
if (T) {
printf("%d",T->data); //调用操作结点数据的函数方法
PreOrderTraverse(T->lchild);//访问该结点的左孩子
PreOrderTraverse(T->rchild);//访问该结点的右孩子
}
}对于顺序表存储的二叉树，非递归实现先序遍历二叉树的代码如下：
//全局变量，记录栈顶的位置
int top = -1;
//前序遍历使用的入栈函数
void push(BiTree a, int elem) {
a[++top] = elem;
}
//弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//拿到栈顶元素
int getTop(BiTree a) {
return a[top];
}
//先序遍历顺序表中的完全二叉树
void PreOrderTraverse(BiTree Tree) {
//模拟栈，记录入栈结点所在顺序表中的下标
int ad[NODENUM] = { 0 };
int p;
//根节点所在的顺序表下标先入栈
push(ad,0);
//直到栈中为空
while (top != -1)
{
//取出一个下标
p = getTop(ad);
pop(ad);
//判断当前下标是否超出结点的总数
while (p < NODENUM)
{
//输出 p 下标处存储的结点值
printf("%d ", Tree[p]);
//找到该结点的右孩子，该它的数组下标入栈
if ((2 * p + 2 < NODENUM) && (Tree[2 * p + 2] != 0)) {
push(ad, 2 * p + 2);
}
//找到 p 下标结点的左孩子，并继续遍历
p = 2 * p + 1;
}
}
}对于链表存储的二叉树，非递归实现先序遍历二叉树的代码如下：
//全局变量，记录栈顶的位置
int top = -1;
//前序遍历使用的进栈函数
void push(BiTree* a, BiTree elem) {
a[++top] = elem;
}
//弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//拿到栈顶元素
BiTNode* getTop(BiTree* a) {
return a[top];
}
//先序遍历二叉树
void PreOrderTraverse(BiTree Tree) {
BiTNode* a[20];//定义一个顺序栈
BiTNode* p;//临时指针
push(a, Tree);//根结点进栈
while (top != -1) {
p = getTop(a);//取栈顶元素
pop();//弹栈
while (p) {
printf("%d ", p->data);//调用结点的操作函数
//如果该结点有右孩子，右孩子进栈
if (p->rchild) {
push(a, p->rchild);
}
p = p->lchild;//一直指向根结点最后一个左孩子
}
}
}5.3.2 二叉树的中序遍历
二叉树的中序遍历，指的是从根结点出发，按照以下步骤访问二叉树中的每个结点：
（1）先进入当前结点的左子树，以同样的步骤遍历左子树中的结点。
（2）访问当前结点。
（3）最后进入当前结点的右子树，以同样的步骤遍历右子树中的结点。
对于顺序表存储的二叉树，递归实现中序遍历的代码如下：
void INOrderTraverse(BiTree T, int p) {
//递归遍历左子树
if (((2 * p + 1) < NODENUM) && (T[2 * p + 1] != 0)) {
INOrderTraverse(T, 2 * p + 1);
}
//访问当前结点
printf("%d ", T[p]);
//递归遍历右子树
if (((2 * p + 2) < NODENUM) && (T[2 * p + 2] != 0)){
INOrderTraverse(T, 2 * p + 2);
}
}对于链表存储的二叉树，递归实现中序遍历的代码如下：
void INOrderTraverse(BiTree T) {
if (T) {
INOrderTraverse(T->lchild);//遍历当前结点的左子树
printf("%d ",T->data); //访问当前结点
INOrderTraverse(T->rchild);//遍历当前结点的右子树
}
} 非递归中序遍历一棵树二叉树，具体有两种实现方案：
（1）从根结点开始，不断地遍历当前结点的左子树并将该结点压入栈中，直至不再有左子树。然后从栈顶取出一个结点并访问它，然后将它的右孩子压入栈中，继续以同样的方式遍历它的右子树；
（2）和方案一唯一的不同之处在于，压入栈中的只会是每个结点的左孩子，右孩子不需要入栈。
对于顺序表存储的二叉树，以上两种方案对应的代码分别是如下：
//全局变量，记录栈顶的位置
int top = -1;
//前序遍历使用的入栈函数
void push(BiTree a, int elem) {
a[++top] = elem;
}
//弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//拿到栈顶元素
int getTop(BiTree a) {
return a[top];
}
//方案1
void InOrderTraverse1(BiTree Tree) {
//模拟栈，记录入栈结点所在顺序表中的下标
int ad[NODENUM] = { 0 };
int p;
push(ad, 0);//根节点的数组下标入栈
//直至栈为空，中序遍历才结束
while (top != -1) {
//不断的将各个结点的左孩子入栈
while ((p = getTop(ad)) < NODENUM) {
if (Tree[p] == 0) {
break;
}
push(ad, 2 * p + 1);
}
pop();//栈顶的下标肯定超出了 NODENUM 指定范围，直接弹出
//不再有左子树之后，访问当前结点，并将其右子树入栈
if (top != -1) {
p = getTop(ad);
pop();
printf("%d ", Tree[p]);
push(ad, p * 2 + 2);
}
}
}
//方案2
void InOrderTraverse2(BiTree Tree) {
//模拟栈，记录入栈结点所在顺序表中的下标
int ad[NODENUM] = { 0 };
int p = 0;
while (p < NODENUM || top != -1) {
//将每个结点的左孩子入栈
if (p < NODENUM && Tree[p] != 0) {
push(ad, p);
p = p * 2 + 1;
}
else
{
//如果栈空，则中序遍历结束
if (top == -1) {
break;
}
//访问该结点，并将其右孩子的下标赋值给 p，继续遍历右子树
p = getTop(ad);
pop();
printf("%d ", Tree[p]);
p = p * 2 + 2;
}
}
}对于链表存储的二叉树，以上两种方案对应的代码如下：
//全局变量，表示栈顶
int top = -1;
//前序和中序遍历使用的进栈函数
void push(BiTNode** a, BiTNode* elem) {
a[++top] = elem;
}
//弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//查看栈顶元素
BiTNode* getTop(BiTNode** a) {
return a[top];
}
//方案1
void InOrderTraverse1(BiTree Tree) {
BiTNode* a[20];//定义一个顺序栈
BiTNode* p;//临时指针
push(a, Tree);//根结点进栈
while (top != -1) {//top!=-1说明栈内不为空，程序继续运行
while ((p = getTop(a)) && p) {//取栈顶元素，且不能为NULL
push(a, p->lchild);//将该结点的左孩子进栈，如果没有左孩子，NULL进栈
}
pop();//跳出循环，栈顶元素肯定为NULL，将NULL弹栈
if (top != -1) {
p = getTop(a);//取栈顶元素
pop();//栈顶元素弹栈
printf("%d ", p->data);
push(a, p->rchild);//将p指向的结点的右孩子进栈
}
}
}
//方案2
void InOrderTraverse2(BiTree Tree) {
BiTNode* a[20];//定义一个顺序栈
BiTNode* p;//临时指针
p = Tree;
//当p为NULL或者栈为空时，表明树遍历完成
while (p || top != -1) {
//如果p不为NULL，将其压栈并遍历其左子树
if (p) {
push(a, p);
p = p->lchild;
}
//如果p==NULL，表明左子树遍历完成，需要遍历上一层结点的右子树
else {
p = getTop(a);
pop();
printf("%d ", p->data);
p = p->rchild;
}
}
}5.3.3 二叉树的后序遍历
后序遍历二叉树，指的是从根结点出发，按照以下步骤访问树中的每个结点：
（1）优先进入当前结点的左子树，以同样的步骤遍历左子树中的结点。
（2）如果当前结点没有左子树，则进入它的右子树，以同样的步骤遍历右子树中的结点。
（3）直到当前结点的左子树和右子树都遍历完后，才访问该结点。
对于顺序表存储的二叉树，递归实现后序遍历的代码如下：
void PostOrderTraverse(BiTree T, int p) {
if ((p * 2 + 1 < NODENUM) && (T[p * 2 + 1] != 0)) {
PostOrderTraverse(T, 2 * p + 1);
}
if ((p * 2 + 2 < NODENUM) && (T[p * 2 + 2] != 0)) {
PostOrderTraverse(T, 2 * p + 2);
}
printf("%d ", T[p]);
}对于链表存储的二叉树，递归实现后序遍历的代码如下：
void PostOrderTraverse(BiTree T) {
if (T) {
PostOrderTraverse(T->lchild);//遍历左孩子
PostOrderTraverse(T->rchild);//遍历右孩子
printf("%d ", T->data);
}
}对于顺序表存储的二叉树，非递归实现后序遍历的代码如下：
#include <stdio.h>
#define NODENUM 7
#define ElemType int
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[NODENUM];
int top = -1;//表示栈顶
typedef struct SNode {
int p; //结点所在顺序表的下标
int tag; //标记值
}SNode;
//存储二叉树
void InitBiTree(BiTree T) {
ElemType node;
int i = 0;
printf("按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:");
while (scanf("%d", &node))
{
T[i] = node;
i++;
}
}
// 弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//入栈
void push(SNode* a, SNode sdata) {
a[++top] = sdata;
}
void PostOrderTraverse(BiTree Tree) {
SNode a[20] = {0};//定义一个顺序栈
int tag; //记录结点的标记位
SNode sdata;
int p = 0;
while (p < NODENUM || top != -1) {
//压入结点的左子树
while (p < NODENUM && Tree[p] != 0) {
sdata.p = p;
sdata.tag = 0;
push(a, sdata);
p = p * 2 + 1;//继续遍历左孩子
}
//取栈顶元素
sdata = a[top];
pop();
p = sdata.p;
tag = sdata.tag;
//如果tag==0，说明该结点还没有遍历它的右孩子
if (tag == 0) {
sdata.p = p;
sdata.tag = 1;
push(a,sdata);
p = p * 2 + 2;//继续遍历右子树
}
//如果取出来的栈顶元素的tag==1，说明此结点左右子树都遍历完了，可以访问该结点了
else
{
printf("%d ", Tree[p]);
p = NODENUM;//重置 p 的值，防止下次进入第一个循环
}
}
}
int main() {
BiTree T = { 0 };
InitBiTree(T);
PostOrderTraverse(T);
return 0;
}对于链表存储的二叉树，非递归实现后序遍历的代码如下：
#include <stdio.h>
#include <stdlib.h>
#define TElemType int
int top = -1;//表示栈顶
typedef struct BiTNode {
TElemType data;//数据域
struct BiTNode* lchild, * rchild;//左右孩子指针
}BiTNode, * BiTree;
//后序遍历非递归算法
typedef struct SNode {
BiTree p;
int tag;
}SNode;
void CreateBiTree(BiTree* T) {
int num;
scanf("%d", &num);
//如果输入的值为 0，表示无此结点
if (num == 0) {
*T = NULL;
}
else
{
//创建新结点
*T = (BiTree)malloc(sizeof(BiTNode));
(*T)->data = num;
CreateBiTree(&((*T)->lchild));//创建该结点的左孩子
CreateBiTree(&((*T)->rchild));//创建该结点的右孩子
}
}
//弹栈函数
void pop() {
if (top == -1) {
return;
}
top--;
}
//入栈
void push(SNode* a, SNode sdata) {
a[++top] = sdata;
}
//后序遍历二叉树
void PostOrderTraverse(BiTree Tree) {
SNode a[20];//定义一个顺序栈
BiTNode* p = NULL;//临时指针
int tag; //记录结点的标记位
SNode sdata;
p = Tree;
while (p || (top != -1)) {
while (p) {
//为该结点入栈做准备
sdata.p = p;
sdata.tag = 0;//由于遍历是左孩子，设置标志位为0
push(a, sdata);//压栈
p = p->lchild;//以该结点为根结点，遍历左孩子
}
sdata = a[top];//取栈顶元素
pop();//栈顶元素弹栈
p = sdata.p;
tag = sdata.tag;
//如果tag==0，说明该结点还没有遍历它的右孩子
if (tag == 0) {
sdata.p = p;
sdata.tag = 1;
push(a, sdata);//更改该结点的标志位，重新压栈
p = p->rchild;//以该结点的右孩子为根结点，重复循环
}
//如果取出来的栈顶元素的tag==1，说明此结点左右子树都遍历完了，可以访问该结点了
else {
printf("%d ", p->data);
p = NULL;
}
}
}
//后序遍历二叉树，释放树占用的内存
void DestroyBiTree(BiTree T) {
if (T) {
DestroyBiTree(T->lchild);//销毁左孩子
DestroyBiTree(T->rchild);//销毁右孩子
free(T);//释放结点占用的内存
}
}
int main() {
BiTree Tree;
CreateBiTree(&Tree);
PostOrderTraverse(Tree);
DestroyBiTree(Tree);
return 0;
}5.3.4 二叉树的层次遍历
层次遍历用链表存储的二叉树，可以借助队列存储结构实现，具体方案是：
（1）将根结点入队；
（2）从队列的头部提取一个结点并访问它，将该结点的左孩子和右孩子依次入队；
（3）重复执行第 2 步，直至队列为空；
对于顺序表存储的二叉树，层次遍历二叉树的代码如下：
#include <stdio.h>
#define NODENUM 7 //二叉树中结点的个数
#define ElemType int
//自定义 BiTree 类型，表示二叉树
typedef ElemType BiTree[NODENUM];
//顺序表存储二叉树
void InitBiTree(BiTree T) {
ElemType node;
int i = 0;
printf("按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:");
while (scanf("%d", &node))
{
T[i] = node;
i++;
}
}
//层次遍历二叉树
void LevelOrderTraverse(BiTree T) {
int j;
//从根结点起,层次遍历二叉树
for (j = 0; j < NODENUM; j++) {
//只访问非空结点
if (T[j] != 0) {
printf("%d ", T[j]);
}
}
}
int main() {
int res;
BiTree T = { 0 };
InitBiTree(T);
LevelOrderTraverse(T);
return 0;
}对于链表存储的二叉树，层次遍历二叉树的代码如下：
#include <stdio.h>
#include <stdlib.h>
#define TElemType int
#define NODENUM 7
//初始化队头和队尾指针开始时都为0
int front = 0, rear = 0;
typedef struct BiTNode {
TElemType data;//数据域
struct BiTNode* lchild, * rchild;//左右孩子指针
}BiTNode, * BiTree;
//以先序遍历的方式存储二叉树到链表中
void CreateBiTree(BiTree* T) {
int num;
scanf("%d", &num);
//如果输入的值为 0，表示无此结点
if (num == 0) {
*T = NULL;
}
else
{
//创建新结点
*T = (BiTree)malloc(sizeof(BiTNode));
(*T)->data = num;
CreateBiTree(&((*T)->lchild));//创建该结点的左孩子
CreateBiTree(&((*T)->rchild));//创建该结点的右孩子
}
}
//入队函数
void EnQueue(BiTree* a, BiTree node) {
if (rear == NODENUM) {
printf("队列已满，入队失败\n");
exit(0);
}
a[rear++] = node;
}
//出队函数
BiTNode* DeQueue(BiTNode** a) {
if (front == rear) {
printf("队列为空，出队失败\n");
exit(0);
}
return a[front++];
}
//层次遍历二叉树
void LevelOrderTraverse(BiTree T) {
//如果二叉树存在，才进行层次遍历
if (T) {
BiTree a[20] = { 0 };
BiTree p = NULL;
p = T;
//根结点入队
EnQueue(a, p);
//重复执行，直至队列为空
while (front < rear)
{
//从队列取出一个结点
p = DeQueue(a);
//访问当前结点
printf("%d ", p->data);
//将当前结点的左右孩子依次入队
if (p->lchild) {
EnQueue(a, p->lchild);
}
if (p->rchild) {
EnQueue(a, p->rchild);
}
}
}
}
//后序遍历二叉树，释放树占用的内存
void DestroyBiTree(BiTree T) {
if (T) {
DestroyBiTree(T->lchild);//销毁左孩子
DestroyBiTree(T->rchild);//销毁右孩子
free(T);//释放结点占用的内存
}
}
int main() {
BiTree Tree;
CreateBiTree(&Tree);
LevelOrderTraverse(Tree);
DestroyBiTree(Tree);
return 0;
}5.4 哈夫曼树（最优二叉树）
5.4.1 哈夫曼树的定义
当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。
在构建哈弗曼树时，要使树的带权路径长度最小，只需要遵循一个原则，那就是：权重越大的结点离树根越近。
对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法如下：
（1）在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和。
（2）在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推。
（3）重复 步骤 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。
哈夫曼树中结点构成用代码如下：
//哈夫曼树结点结构
typedef struct {
int weight;//结点权重
int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;5.4.2 构建哈弗曼树
构建哈夫曼树时，需要每次根据各个结点的权重值，筛选出其中值最小的两个结点，然后构建二叉树。
查找权重值最小的两个结点的思想是：从树组起始位置开始，首先找到两个无父结点的结点（说明还未使用其构建成树），然后和后续无父结点的结点依次做比较，有两种情况需要考虑：
（1）如果比两个结点中较小的那个还小，就保留这个结点，删除原来较大的结点。
（2）如果介于两个结点权重值之间，替换原来较大的结点。
实现代码：
//HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
void Select(HuffmanTree HT, int end, int* s1, int* s2)
{
int min1, min2;
int i = 1, j;
//找到还没构建树的结点
while (HT[i].parent != 0 && i <= end) {
i++;
}
min1 = HT[i].weight;
*s1 = i;
i++;
while (HT[i].parent != 0 && i <= end) {
i++;
}
//对找到的两个结点比较大小，min2为大的，min1为小的
if (HT[i].weight < min1) {
min2 = min1;
*s2 = *s1;
min1 = HT[i].weight;
*s1 = i;
}
else {
min2 = HT[i].weight;
*s2 = i;
}
//两个结点和后续的所有未构建成树的结点做比较
for (j = i + 1; j <= end; j++)
{
//如果有父结点，直接跳过，进行下一个
if (HT[j].parent != 0) {
continue;
}
//如果比最小的还小，将min2=min1，min1赋值新的结点的下标
if (HT[j].weight < min1) {
min2 = min1;
min1 = HT[j].weight;
*s2 = *s1;
*s1 = j;
}
//如果介于两者之间，min2赋值为新的结点的位置下标
else if (HT[j].weight >= min1 && HT[j].weight < min2) {
min2 = HT[j].weight;
*s2 = j;
}
}
}
//HT为地址传递的存储哈夫曼树的数组，w为存储结点权重值的数组，n为结点个数
void CreateHuffmanTree(HuffmanTree* HT, int* w, int n)
{
int m, i;
if (n <= 1) return; // 如果只有一个编码就相当于0
m = 2 * n - 1; // 哈夫曼树总节点数，n就是叶子结点
*HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode)); // 0号位置不用
HuffmanTree p = *HT;
// 初始化哈夫曼树中的所有结点
for (i = 1; i <= n; i++)
{
(p + i)->weight = *(w + i - 1);
(p + i)->parent = 0;
(p + i)->left = 0;
(p + i)->right = 0;
}
//从树组的下标 n+1 开始初始化哈夫曼树中除叶子结点外的结点
for (i = n + 1; i <= m; i++)
{
(p + i)->weight = 0;
(p + i)->parent = 0;
(p + i)->left = 0;
(p + i)->right = 0;
}
//构建哈夫曼树
for (i = n + 1; i <= m; i++)
{
int s1, s2;
Select(*HT, i - 1, &s1, &s2);
(*HT)[s1].parent = (*HT)[s2].parent = i;
(*HT)[i].left = s1;
(*HT)[i].right = s2;
(*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
}
}
735
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
