哈夫曼树 哈夫曼编码(先序遍历方法)
树的遍历和哈夫曼树
2021/4/18 北京化工大学信息学院 数据结构 33
求二叉树高度的递归算法
int Height ( BinTreeNode * T ) { if ( T == NULL ) return -1; else { int m = Height ( T->leftChild ); int n = Height ( T->rightChild ) ); return (m > n) ? m+1 : n+1;
中序遍历 (Inorder Traversal)
中序遍历二叉树算法的框架是：
若二叉树为空，则空操作；
-
否则 中序遍历左子树 (L)；
+
/
访问根结点 (V)；
a *e f
中序遍历右子树 (R)。
遍历结果
b-
a+b*c-d-e/f
cd
2021/4/18 北京化工大学信息学院 数据结构 20
二叉树递归的中序遍历算法
如果 n = 0，称为空树；如果 n > 0，则 ▪ 有一个特定的称之为根(root)的结点，
它只有直接后继，但没有直接前驱； ▪ 除根以外的其它结点划分为 m (m 0)
个 互不相交的有限集合T0, T1, …, Tm-1，每 个集合又是一棵树，并且称之为根的子树。
2021/4/18 北京化工大学信息学院 数据结构 3
typedef struct node { //树结点定义
TreeData data;
//结点数据域
struct node * leftChild, * rightchild;
//子女指针域
} BinTreeNode;
typedef BinTreeNode * BinTree; //树定义，代表树的根指针
最优二叉树（哈夫曼树）的构建及编码
最优⼆叉树（哈夫曼树）的构建及编码参考：数据结构教程（第五版）李春葆主编⼀，概述1，概念 结点的带权路径长度： 从根节点到该结点之间的路径长度与该结点上权的乘积。
树的带权路径长度： 树中所有叶结点的带权路径长度之和。
2，哈夫曼树（Huffman Tree） 给定 n 个权值作为 n 个叶⼦结点，构造⼀棵⼆叉树，若该树的带权路径长度达到最⼩，则称这样的⼆叉树为最优⼆叉树，也称为哈夫曼树。
哈夫曼树是带权路径长度最短的树，权值较⼤的结点离根较近。
⼆，哈夫曼树的构建1，思考 要实现哈夫曼树⾸先有个问题摆在眼前，那就是哈夫曼树⽤什么数据结构表⽰？ ⾸先，我们想到的肯定数组了，因为数组是最简单和⽅便的。
⽤数组表⽰⼆叉树有两种⽅法： 第⼀种适⽤于所有的树。
即利⽤树的每个结点最多只有⼀个⽗节点这种特性，⽤ p[ i ] 表⽰ i 结点的根节点，进⽽表⽰树的⽅法。
但这种⽅法是有缺陷的，权重的值需要另设⼀个数组表⽰；每次找⼦节点都要遍历⼀遍数组，⼗分浪费时间。
第⼆种只适⽤于⼆叉树。
即利⽤⼆叉树每个结点最多只有两个⼦节点的特点。
从下标 0 开始表⽰根节点，编号为 i 结点即为 2 * i + 1 和 2 * i + 2，⽗节点为 ( i - 1) / 2，没有⽤到的空间⽤ -1 表⽰。
但这种⽅法也有问题，即哈夫曼树是从叶结点⾃下往上构建的，⼀开始树叶的位置会因为⽆法确定⾃⾝的深度⽽⽆法确定，从⽽⽆法构造。
既然如此，只能⽤⽐较⿇烦的结构体数组表⽰⼆叉树了。
typedef struct HTNode // 哈夫曼树结点{double w; // 权重int p, lc, rc;}htn;2，算法思想 感觉⽐较偏向于贪⼼，权重最⼩的叶⼦节点要离根节点越远，⼜因为我们是从叶⼦结点开始构造最优树的，所以肯定是从最远的结点开始构造，即权重最⼩的结点开始构造。
所以先选择权重最⼩的两个结点，构造⼀棵⼩⼆叉树。
然后那两个最⼩权值的结点因为已经构造完了，不会在⽤了，就不去考虑它了，将新⽣成的根节点作为新的叶⼦节加⼊剩下的叶⼦节点，⼜因为该根节点要能代表整个以它为根节点的⼆叉树的权重，所以其权值要为其所有⼦节点的权重之和。
c语言 哈夫曼树哈夫曼编码
c语言哈夫曼树哈夫曼编码哈夫曼树（Huffman Tree）和哈夫曼编码（Huffman Coding）是由戴维·哈夫曼在1952年为数据压缩应用而发明的。
哈夫曼编码是一种前缀编码，即任何字符的编码都不是另一个字符的编码的前缀。
在编码学中，哈夫曼编码是一种可变长度编码，其中较常见或较频繁的字符使用较短的编码，而较少见或较不频繁的字符使用较长的编码。
这种编码是由哈夫曼树生成的，哈夫曼树是一种特殊的二叉树，其每个节点的权重等于其左子树和右子树的权重之和。
在C语言中实现哈夫曼树和哈夫曼编码可能涉及以下步骤：1、定义哈夫曼树的节点结构。
每个节点可能包括字符，权重（或频率），以及左孩子和右孩子的指针。
ctypedef struct huffman_node {char character;unsigned int frequency;struct huffman_node *left, *right;} huffman_node;2、创建哈夫曼树。
首先，你需要计算每个字符的频率，然后根据这些频率创建一个哈夫曼树。
这个过程可能涉及使用优先队列（最小堆）来找出频率最小的两个节点，然后将它们合并为一个新的节点，新节点的频率是这两个节点的频率之和。
然后，将新节点放回队列中，重复这个过程直到队列中只剩下一个节点，这个节点就是你的哈夫曼树的根节点。
3、使用哈夫曼树生成哈夫曼编码。
从根节点开始，对于每个字符，左子树代表0，右子树代表1。
你可以遍历哈夫曼树，为每个字符生成其对应的哈夫曼编码。
4、实现解码。
给定一个哈夫曼编码，你可以通过遍历哈夫曼树来解码它。
对于每个位，如果是0，你跟随左子树，如果是1，你跟随右子树。
当你到达一个叶节点时，你就找到了对应的字符。
以上只是一个大致的步骤，具体的实现可能会根据你的需求和具体情况有所不同。
c语言哈夫曼树的构造及编码
c语言哈夫曼树的构造及编码一、哈夫曼树概述哈夫曼树是一种特殊的二叉树，它的构建基于贪心算法。
它的主要应用是在数据压缩和编码中，可以将频率高的字符用较短的编码表示，从而减小数据存储和传输时所需的空间和时间。
二、哈夫曼树的构造1. 哈夫曼树的定义哈夫曼树是一棵带权路径长度最短的二叉树。
带权路径长度是指所有叶子节点到根节点之间路径长度与其权值乘积之和。
2. 构造步骤(1) 将待编码字符按照出现频率从小到大排序。
(2) 取出两个权值最小的节点作为左右子节点，构建一棵新的二叉树。
(3) 将新构建的二叉树加入到原来排序后队列中。
(4) 重复上述步骤，直到队列只剩下一个节点，该节点即为哈夫曼树的根节点。
3. C语言代码实现以下代码实现了一个简单版哈夫曼树构造函数：```ctypedef struct TreeNode {int weight; // 权重值struct TreeNode *leftChild; // 左子节点指针struct TreeNode *rightChild; // 右子节点指针} TreeNode;// 构造哈夫曼树函数TreeNode* createHuffmanTree(int* weights, int n) {// 根据权值数组构建节点队列，每个节点都是一棵单独的二叉树TreeNode** nodes = (TreeNode**)malloc(sizeof(TreeNode*) * n);for (int i = 0; i < n; i++) {nodes[i] = (TreeNode*)malloc(sizeof(TreeNode));nodes[i]->weight = weights[i];nodes[i]->leftChild = NULL;nodes[i]->rightChild = NULL;}// 构建哈夫曼树while (n > 1) {int minIndex1 = -1, minIndex2 = -1;for (int i = 0; i < n; i++) {if (nodes[i] != NULL) {if (minIndex1 == -1 || nodes[i]->weight < nodes[minIndex1]->weight) {minIndex2 = minIndex1;minIndex1 = i;} else if (minIndex2 == -1 || nodes[i]->weight < nodes[minIndex2]->weight) {minIndex2 = i;}}}TreeNode* newNode =(TreeNode*)malloc(sizeof(TreeNode));newNode->weight = nodes[minIndex1]->weight + nodes[minIndex2]->weight;newNode->leftChild = nodes[minIndex1];newNode->rightChild = nodes[minIndex2];// 将新构建的二叉树加入到原来排序后队列中nodes[minIndex1] = newNode;nodes[minIndex2] = NULL;n--;}return nodes[minIndex1];}```三、哈夫曼编码1. 哈夫曼编码的定义哈夫曼编码是一种前缀编码方式，它将每个字符的编码表示为二进制串。
哈夫曼树和哈夫曼编码(数据结构程序设计)
课程设计（数据结构）哈夫曼树和哈夫曼编码二○○九年六月二十六日课程设计任务书及成绩评定课题名称表达式求值哈夫曼树和哈夫曼编码Ⅰ、题目的目的和要求：巩固和加深对数据结构的理解，通过上机实验、调试程序，加深对课本知识的理解，最终使学生能够熟练应用数据结构的知识写程序。
（1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。
（2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构（C语言版）清华大学出版社 1999[2] 严蔚敏数据结构题集（C语言版）清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定：设计成绩：（教师填写）指导老师：（签字）二○○九年六月二十六日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计及实现代码 (8)第五章调试过程中的问题及系统测试情况 (12)第六章结束语 (13)参考文献 (13)第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
课程设计是让同学们对所学的课程更全面的学习和应用，理解和掌握课程的相关知识。
《数据结构》是一门重要的专业基础课，是计算机理论和应用的核心基础课程。
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是表达式求值和哈夫曼树及哈夫曼编码。
这里我们介绍一种简单直观、广为使用的算法，通常称为“算符优先法”。
哈夫曼树又称最优树，是一类带权路径长度最短的树，有着广泛的应用。
哈夫曼树的编码和解码
哈夫曼树的编码和解码是哈夫曼编码算法的重要部分，下面简要介绍其步骤：
1. 编码：
哈夫曼编码是一种变长编码方式，对于出现频率高的字符使用较短的编码，而对于出现频率低的字符使用较长的编码。
具体步骤如下：（1）根据字符出现的频率，构建哈夫曼树。
频率相同的字符，按照它们在文件中的出现顺序排列。
（2）从哈夫曼树的叶子节点开始，从下往上逐步进行编码。
对于每个节点，如果该节点有左孩子，那么左孩子的字符编码为0，右孩子的字符编码为1。
如果该节点是叶子节点，则该节点的字符就是它的编码。
（3）对于哈夫曼树中的每个节点，都记录下它的左孩子和右孩子的位置，以便后续的解码操作。
2. 解码：
解码过程与编码过程相反，具体步骤如下：
（1）从哈夫曼树的根节点开始，沿着路径向下遍历树，直到找到一个终止节点（叶节点）。
（2）根据终止节点的位置信息，找到对应的字符。
（3）重复上述步骤，直到遍历完整个编码序列。
需要注意的是，哈夫曼编码是一种无损压缩算法，解压缩后的数据与原始数据完全相同。
此外，由于哈夫曼编码是一种变长编码方式，因此在解码时需要从根节点开始逐个解码，直到解码完成。
哈夫曼树及哈夫曼编码的程序-附流程图（下）
哈夫曼树及哈夫曼编码的程序-附流程图（下）int m,s1,s2;typedef struct {unsigned int weight;unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char *HuffmanCode;void Select(HuffmanTree HT,int n) {int i,j;for(i = 1;i <= n;i++)if(!HT[i].parent){s1 = i;break;}for(j = i+1;j <= n;j++)if(!HT[j].parent){s2 = j;break;}for(i = 1;i <= n;i++)if((HT[s1].weight>HT[i].weight)&&(!HT[i].parent)&&(s2!=i))s1=i;for(j = 1;j <= n;j++)if((HT[s2].weight>HT[j].weight)&&(!HT[j].parent)&&(s1!=j))s2=j;}void HuffmanCoding(HuffmanTree &HT, HuffmanCode HC[], int *w, int n) {int i, j;char *cd;int p;int cdlen;if (n<=1) return;m = 2 * n - 1;HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode));for (i=1; i<=n; i++) {HT[i].weight=w[i-1];HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for (i=n+1; i<=m; i++) {HT[i].weight=0;HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}puts("\n哈夫曼树的构造过程如下所⽰：");printf("HT初态:\n 结点 weight parent lchild rchild");for (i=1; i<=m; i++)printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,HT[i].parent,HT[i].lchild, HT[i].rchild);printf(" 按任意键，继续 ...");getchar();for (i=n+1; i<=m; i++) {Select(HT, i-1);HT[s1].parent = i; HT[s2].parent = i;HT[i].lchild = s1; HT[i].rchild = s2;HT[i].weight = HT[s1].weight + HT[s2].weight;printf("\nselect: s1=%d s2=%d\n", s1, s2);printf(" 结点 weight parent lchild rchild");for (j=1; j<=i; j++)printf("\n%4d%8d%8d%8d%8d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);printf(" 按任意键，继续 ...");getchar(); }cd = (char *)malloc(n*sizeof(char));p = m; cdlen = 0;for (i=1; i<=m; ++i)HT[i].weight = 0;while (p) {if (HT[p].weight==0) {HT[p].weight = 1;if (HT[p].lchild != 0) { p = HT[p].lchild; cd[cdlen++] ='0'; } else if (HT[p].rchild == 0){ HC[p] = (char *)malloc((cdlen+1) * sizeof(char));cd[cdlen] ='\0'; strcpy(HC[p], cd); }}else if (HT[p].weight==1){ HT[p].weight = 2;if (HT[p].rchild != 0) { p = HT[p].rchild; cd[cdlen++] ='1'; }} else { // HT[p].weight==2，HT[p].weight = 0; p = HT[p].parent; --cdlen; } }}void main() {HuffmanTree HT;HuffmanCode *HC;int *w,n,i;puts("输⼊结点数:");scanf("%d",&n);HC = (HuffmanCode *)malloc(n*sizeof(HuffmanCode));w = (int *)malloc(n*sizeof(int));printf("输⼊%d个结点的权值\n",n);for(i = 0;i < n;i++)scanf("%d",&w[i]);HuffmanCoding(HT,HC,w,n);puts("\n各结点的哈夫曼编码:");for(i = 1;i <= n;i++)printf("%2d(%4d):%s\n",i,w[i-1],HC[i]);getchar(); }。
计算机数据结构知识点梳理 哈夫曼(Huffman)树和哈夫曼编码
（3）在集合F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入 到集合F中；
（4）重复（2）（3）两步，当F中只剩下一棵二叉树时，这棵二叉树便是所要 建立的哈夫曼树。
（3）深度为h的哈夫曼树，其叶子结点的最大编码长度为h-1。
[题1]若度为m的哈夫曼树，其叶子结点个数为n，则非叶子结点 的个数为（ ）。
A.n-1 B.[n/m]-1 C.[(n-1)/(m-1)] D.[n/(m-1)]-1
分析：在构造度为m的哈夫曼树过程中，每次把m个子结点合并 为一个父结点（第一次合并可能少于m个子结点），每次合并 减少m-1个结点，从n个叶子结点减少到最后只剩一个父结点共 需[(n-1)/(m-1)]次合并，每次合并增加一个非叶子结点。
5、对哈夫曼树编码的总结
（1）哈夫曼编码是能使电文代码总长最短的编码方式。此结论由哈夫曼树是带 权路径长度最小的树的特征可得。
（2）哈夫曼编码是一种前缀编码，保证其在译码时不会产生歧义。因为，在哈 夫曼编码中，每个字符都是叶子结点，而叶子结点不可能从根结点到其他叶 子结点的路径上，所以一个字符的哈夫曼编码不可能是另一个字符的哈夫曼 编码的前缀。
知识点10：哈夫曼（HUFFMAN）树和哈夫曼编码
1、哈夫曼树（又称最优二叉树），是指对于一 组带有确定权值的叶结点，构造的具有最小带
权路径长度的二叉树。
2、哈夫曼树的构造方法的基本思想
（1）由给定的n个权值{W1，W2，…，Wn}构造n棵只有一个叶结点的二叉树， 从而得到一个二叉树的集合F＝{T1，T2，…，Tn}；
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
for(i=0;i<2*n-1;i++)
{
printf("%d,", Huffman[i]->weight);
}
printf("\n");
for(i=0;i<2*n-1;i++)
{
printf("%d的左结点的下标为%d,右结点的下标为%d\n",Huffman[i]->weight,Huffman[i]->left,Huffman[i]->right);
{
if(i==1 && k==0 )
{
q[i] = Huffman[x];
s[i-1] = '*';
k++;
}
while(q[i]->left !=-1 && ls[i] == 0)
{
x =Huffman[x]->left;
ls[i] = 1; i++; k++;
q[i] = Huffman[x];
{
m1 = Huffman[j]->weight ;
x1 = j;
}
}
for(j=0;j<n+i;j++)
{
if( Huffman[j]->weight < m2 && Huffman[j]->parent == -1 && x1 != j)
{
m2 = Huffman[j]->weight ;
x2 = j;
tree Huffman[100];
for(i=0;i< 2*n-1;i++)
{
Huffman[i] = (tree) malloc(sizeof(struct Tree));
}
for(i=0;i<n;i++)
{
scanf("%d",&Huffman[i]->weight);
}
for(i=0;i<2*n-1;i++)
{
Huffman[i]->parent = -1;
Huffman[i]->left = -1;
Huffman[i]->right = -1;}int j;
for(i=0;i<n-1;i++)
{
m1= m2= 65536;
x1 =x2 = 0;
for(j=0;j<n+i;j++)
{
if( Huffman[j]->weight < m1 && Huffman[j]->parent == -1)
}
char s[100]; int x; i--; x = i; int k; k=0;
int rs[100];int ls[100]; i=1; tree q[100];
int sum=0;
for(j=0; j<100 ;j++)
{
rs[j] =0;ls[j] =0; s[j]='\0';
}
while( i != 0)
}
}
Huffman[x1]->parent = n+i; Huffman[x2]->parent = n+i;
Huffman[n+i]->weight =Huffman[x1]->weight + Huffman[x2]->weight ;
Huffman[n+i]->left =x1; Huffman[n+i]->right =x2;
#include <stdio.h>
#include <stdlib.h>
typedef struct Tree
{
int weight;
int left;
int right;
int parent;
}*tree;
void CreateHuffman(int n)
{
int i;
int m1,m2,x1,x2;
{
i--; k++;
Huffman[x] =q[i];
}
}
printf("带权长度为%d\n",sum);
}
void main()
{
int num; printf("输入叶子结点个数：");scanf("%d",&num);
CreateHuffman( num);
printf("\n");
}
printf("%c",s[j]);
printf("\n"); sum+= q[i]->weight *(i-1);
}
if( (q[i]->left ==-1 && rs[i] == 1 ) ||(q[i]->left ==-1 && q[i]->right == -1)
||(q[i]->right ==-1 && ls[i] == 1 ) ||( rs[i] ==1&& ls[i] == 1 ) )
s[i-1] ='0';
ls[i] =0; rs[i] = 0;
}
if(( q[i]->left ==-1&& q[i]->right != -1 && rs[i] ==0 ) || (ls[i] ==1 && q[i]->right != -1&& rs[i] ==0 ) )
{
x =Huffman[x]->right;
rs[i] =1;i++; k++;
q[i] = Huffman[x];
s[i-1] ='1';
ls[i] =0; rs[i] = 0;
}
if( (q[i]->left ==-1 && q[i]->right ==-1 ) )
{
printf("%d:",q[i]->weight);
for( j =1 ; j <i;j++)