数据结构考试-哈夫曼编码特辑

合集下载

数据结构：哈夫曼树和哈夫曼编码

数据结构：哈夫曼树和哈夫曼编码哈夫曼树哈夫曼树是⼀种最优⼆叉树，其定义是：给定n个权值作为n个叶⼦节点，构造⼀棵⼆叉树，若树的带权路径长度达到最⼩，这样的树就达到最优⼆叉树，也就是哈夫曼树，⽰例图如下：基本概念深⼊学习哈夫曼树前，先了解⼀下基本概念，并以上⾯的哈夫曼树图为例路径：树中⼀个结点到另⼀个结点之间的分⽀序列构成两个结点间的路径。

路径长度：路径中分⽀的数⽬，从根结点到第L层结点的路径长度为L-1。

例如100和80的路径长度为1，50和30的路径长度为2。

结点的权：树中结点的数值，例如100，50那些。

结点带权路径长度：根结点到该结点之间的路径长度与该结点的权的乘积。

如结点20的路径长度为3，该结点的带权路径长度为：3*20 = 60。

树的带权路径长度：所有叶⼦结点的带权路径长度之和，记为WPL。

例如上图树的WPL = 1100 + 280 +320 +310 = 350。

带权路径长度⽐较前⾯说到，哈夫曼树是最优⼆叉树，因为符合哈夫曼树特点的树的带权路径长度⼀定是最⼩的，我们将哈夫曼树和普通的⼆叉树做个⽐较，仍以上图为例，上图的哈夫曼树是结点10，20，50，100组成的⼆叉树，WPL是350，⽤这四个结点组成普通的⼆叉树，结果如下：不难计算，该⼆叉树的WPL = 210 + 220 + 250 + 2100 = 360，明显⽐哈夫曼树⼤，当然⼆叉树的组成结果不唯⼀，但WPL⼀定⽐哈夫曼树⼤。

所以说哈夫曼树是最优⼆叉树。

哈夫曼树的构造现在假定有n个权值，设为w1、w2、…、wn，将这n个权值看成是有n棵树的森林，根据最⼩带权路径长度的原则，我们可以按照下⾯步骤来将森林构造成哈夫曼树：1. 在森林中选出根结点的权值最⼩的两棵树进⾏合并，作为⼀棵新树的左、右⼦树，且新树的根结点权值为其左、右⼦树根结点权值之和；2. 从森林中删除选取的两棵树，并将新树加⼊森林；3. 重复1、2步，直到森林中只剩⼀棵树为⽌，该树即为所求得的哈夫曼树。

数据结构哈夫曼编码加密文件

数据结构哈夫曼编码加密文件数据结构哈夫曼编码加密文件引言数据结构是计算机科学中非常重要的一门课程，它研究了用于组织和存储数据的各种算法和数据结构。

在计算机科学中，编码是将信息从一种形式转化为另一种形式的过程。

在信息安全领域中，加密（encryption）是保护信息不被未经授权的人员访问的过程。

本文将介绍数据结构中一种常用的编码技术——哈夫曼编码，并且将其应用于文件加密中。

1. 哈夫曼编码哈夫曼编码是一种用于数据压缩的编码技术，由David A. Huffman在1952年提出。

这种编码技术基于树形结构，通过对出现频率较高的字符使用较短的编码，对出现频率较低的字符使用较长的编码，以实现对数据的高效压缩。

哈夫曼编码的构建过程主要分为两个步骤：构建哈夫曼树和哈夫曼编码。

1.1 构建哈夫曼树构建哈夫曼树的过程是通过不断合并权值最小的两个节点，直到只剩下一个根节点。

每个节点都有一个权值，该权值是根据字符在文件中的出现频率来确定的。

在构建哈夫曼树的过程中，节点的权值扮演着重要的作用。

1.2 哈夫曼编码哈夫曼编码的过程是根据哈夫曼树的结构，为每个字符对应的编码。

向左的路径被标记为0，向右的路径被标记为1。

对于每个字符，从根节点开始，通过路径上的0和1，就可以找到对应的编码。

2. 数据结构哈夫曼编码加密文件在文件加密中，可以利用哈夫曼编码对文件中的字符进行加密。

具体的步骤如下：2.1 统计字符出现频率首先，需要统计文件中各个字符的出现频率。

可以使用字典等数据结构来记录每个字符的出现次数。

2.2 构建哈夫曼树根据统计得到的字符出现频率，构建哈夫曼树。

构建哈夫曼树的过程可以使用优先队列等数据结构来辅助。

2.3 哈夫曼编码根据构建的哈夫曼树，为每个字符对应的哈夫曼编码。

可以使用递归或者栈等数据结构来遍历哈夫曼树，编码。

2.4 加密文件利用的哈夫曼编码，对文件中的字符进行加密。

将文件中的每个字符替换为对应的哈夫曼编码。

数据结构哈夫曼编码

数据结构哈夫曼编码【标题】数据结构：深入探索哈夫曼编码的奥秘【引言】数据结构是计算机科学中重要的基础知识，而哈夫曼编码作为一种经典的数据压缩算法更是备受推崇。

本文将深入探索哈夫曼编码的原理与应用，帮助读者全面理解该数据结构的大局及其潜在的威力。

通过从简到繁、由浅入深的方式，本文将层层拆解哈夫曼编码，从而带领读者揭示其背后的奥秘。

【正文】一、哈夫曼编码的概念及基本原理1. 哈夫曼编码的定义哈夫曼编码是一种变长编码方式，将出现频率较高的字符赋予较短的编码，从而实现数据压缩的目的。

其核心思想是根据字符出现频率构建一颗哈夫曼树，对于每个字符的编码规则，以其所在路径的0和1来表示。

2. 哈夫曼编码的构建过程（1）统计字符出现频率，构建字符频率表。

（2）使用字符频率表构建哈夫曼树。

（3）递归遍历哈夫曼树，生成每个字符的编码规则表。

二、哈夫曼编码的应用1. 数据压缩哈夫曼编码的最大优势在于可以有效地减少数据的存储空间，实现数据的压缩。

通过将高频字符赋予短编码，低频字符赋予长编码，哈夫曼编码可以最大程度地降低数据的存储需求。

2. 传输效率提升在数据传输过程中，哈夫曼编码可以减少数据的传输量，提高传输效率。

尤其是在网络传输中，由于带宽的限制，通过使用哈夫曼编码可以显著减少数据传输的时间和资源消耗。

3. 数据加密哈夫曼编码也可以作为一种简单的数据加密手段。

通过将字符的真实含义隐藏在编码中，哈夫曼编码为数据加密提供了一种简单而高效的方法。

三、哈夫曼编码的实际案例1. 文本文件压缩将文本文件进行哈夫曼编码压缩后，可以有效地减少存储空间的占用，提高文件的传输效率。

2. 图像文件压缩在图像文件中，像素的出现频率决定了其在哈夫曼编码中的编码长度。

对于像素出现频率较高的区域，通过哈夫曼编码可以显著减少存储空间，保持图像质量的同时提高传输效率。

3. 音频文件压缩哈夫曼编码在音频文件的压缩中也有广泛应用。

通过合理地构建哈夫曼编码表，可以实现对音频文件的高效压缩和传输。

数据结构课程设计哈夫曼编码实验

数据结构设计性实验Huffman编码与译码学号姓名班级设计性实验—Huffman 编码与译码一．实验目的：在掌握相关基础知识的基础上，学会自己设计实验算法，熟练掌握Huffman 树的建立方法，Huffman 编码的方法，进而设计出Huffman 译码算法，并编程实现。

二．实验要求：在6学时以内，制作出能够实现基于26个英文字母的任意字符串的编译码。

写出技术工作报告并附源程序。

三．实验内容及任务：1．设字符集为26个英文字母，其出现频度如下表所示。

2．建Huffman 树； 3．利用所建Huffman 树对任一字符串文件进行编码——即设计一个Huffman 编码器；4．对任一字符串文件的编码进行译码——即设计一个Huffman 译码器。

实现步骤：1．数据存储结构设计； 2．操作模块设计； 3．建树算法设计； 4．编码器设计；5．译码器设计；51 48 1 15 63 57 20 32 5 1频度z y x w v u t 字符11611882380频度p 21 f q15 g r 47 h s o n m l k j 字符 57 103 32 22 13 64 186 频度 i e d c b a 空格字符四．分析以及算法描述1.分析问题1)首先学习二叉树的知识，了解二叉树的路径、权数以及带权路径长度计算。

2)认识霍夫曼树，了解霍夫曼树的定义，构造霍夫曼树构造算法①又给定的n个权值{w1，w2，w3，……，w n}构造根节点的二叉树，从而得到一个二叉树森林F={T1，T2，T3，……T n}。

②在二叉树森里选取根节点全职最小和此最小的两棵二叉树作为左右节点构造新的二叉树，此时新的二叉树的根节点权值为左右子树权值之和。

③在二叉树森林中删除作为新二叉树的根节点左右子树的两棵二叉树，将新的二叉树加入到二叉树森林F中。

④重复②和③，当二叉树森林F只剩下一棵二叉树时，这棵二叉树是所构造的霍夫曼树。

3)练习通过普通树来构造霍夫曼树。

数据结构C语言哈夫曼编码译码

题目：哈夫曼树编码译码院系：信息工程系专业：计算机科学与技术（网络方向）*名：***学号： **********指导教师：赵莹莹刘欣日期： 2013年7月3日桂林电子科技大学信息科技学院实训报告目录一、设计思想............................. 错误!未定义书签。

1.1建立哈夫曼树的思想................. 错误!未定义书签。

1.2建立哈夫曼编码表................... 错误!未定义书签。

1.3对文件进行编码 (2)1.4对文件进行解码 (2)二、算法流程图 (3)三、运行结果 (8)四、遇到的问题及解决 (10)五、心得体会............................. 错误!未定义书签。

一、设计思想要完成哈夫曼的编码和解码需要首先建立哈夫曼树，之后对所有字符根据权重进行编码，最后再对文件内容进行编码和解码。

1.1建立哈夫曼树的思想。

首先定义适合哈夫曼树的节点类型，需要定义的有当前节点的字符，当前节点的左子、右子和父亲指针。

在建立哈夫曼树之前还需要对出现的字符和权重进行统计和记录，并且定义一个可以筛选出最小权重的函数。

初始化树节点之后开始建立哈夫曼树。

先在所有可能出现的字符中筛选出当前权重最小的两个字符，将这两个字符分别作为新节点的左子和右子建立一个小的二叉树，并将两个字符的权重之和赋值给新节点，将新二叉树放入筛选字符中，再将筛选过的两个字符从筛选列表中淘汰掉。

依次对列表中剩下的字符进行权重最小的筛选，直到根节点（如果编码表共有N个字符，则2*N-1就为最终根节点）为止，也就是当筛选列表为空的时候，哈夫曼树即建立完成。

对于哈夫曼编码树来说，由于哈夫曼编码是前缀码，所以所有要编码的字符最终都将是这颗树的叶子节点，而其它节点并没有真正的字符意义。

即当哈夫曼编码树建立之后，对树的所有叶子节点进行打印可知道是否有字符遗漏或多余。

1.2建立哈夫曼编码表。

数据结构哈弗曼编译码———c语言版

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY数据结构课程设计报告课设题目：哈夫曼(Huffman)编/译码器专业：计算机科学与技术（嵌入式）班级：计算机143姓名：王龙完成日期：2016年1月21日指导教师：魏本昌1、题目的内容及要求【问题描述】利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发站写一个哈夫曼码的编/译码系统。

【任务要求】一个完整的系统应具有以下功能：1)I：初始化（Initialization）。

从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。

2)E：编码（Encoding）。

利用以建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。

3)D：译码（Decoding）。

利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。

4)P：印代码文件（Print）。

将文件CodeFile以紧凑格式显示在终端上，每行50个代码。

同时将此字符形式的编码文件写入文件CodePrin中。

5)T：印哈夫曼树（Tree Printing）。

将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。

2、需求分析利用哈夫曼树(Huffman)编/译码（一）、初始化哈夫曼树（二）、建立哈夫曼树（三）、对哈夫曼树进行编码（四）、输出对应字符的编码（五）、译码过程（六）、输出哈夫曼树3、概要设计（包括选择什么数据结构？数据结构采用哪种存储方式？选择的原因？设计哪些操作？这些操作之间的调用关系等等）选择了线性数据结构，数据结构采用顺序存储方式，选择的原因：结构简单，可以方便调用任何一个数组，无需为结点间的逻辑关系而增加额外的空间。

数据结构c+python代码6：哈夫曼树构造及编码

数据结构c+python代码6：哈夫曼树构造及编码⾸先介绍⼀下什么是哈夫曼树？给定N个权值作为N个叶⼦结点，构造⼀棵⼆叉树，若该树的带权路径长度达到最⼩，称这样的⼆叉树为最优⼆叉树，也称为哈夫曼树(Huffman Tree)。

哈夫曼树是带权路径长度最短的树，权值较⼤的结点离根较近。

哈夫曼树⼜称为最优树.1、路径和路径长度在⼀棵树中，从⼀个结点往下可以达到的孩⼦或孙⼦结点之间的通路，称为路径。

通路中分⽀的数⽬称为路径长度。

若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。

2、结点的权及带权路径长度哈夫曼树哈夫曼树(3张)若将树中结点赋给⼀个有着某种含义的数值，则这个数值称为该结点的权。

结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。

3、树的带权路径长度树的带权路径长度规定为所有叶⼦结点的带权路径长度之和，记为WPL。

哈夫曼树的构造假设有n个权值，则构造出的哈夫曼树有n个叶⼦结点。

n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为：(1) 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有⼀个结点)；(2) 在森林中选出两个根结点的权值最⼩的树合并，作为⼀棵新树的左、右⼦树，且新树的根结点权值为其左、右⼦树根结点权值之和；(3)从森林中删除选取的两棵树，并将新树加⼊森林；(4)重复(2)、(3)步，直到森林中只剩⼀棵树为⽌，该树即为所求得的哈夫曼树。

c代码过程分析构造哈夫曼树算法的实现可以分成两⼤部分：1、初始化：⾸先动态申请2n个单元；然后循环2n-1次，从1号单元开始，依次将1⾄2n-1所有单元中的双亲、左孩⼦、右孩⼦的下标都初始化为0；最后再循环n次，输⼊前n个单元中叶⼦节点的权值。

2、创建树：循环n-1次，通过n-1次的选择、删除与合并来创建哈夫曼树。

选择是从当前森林中选择双亲为0且权值最⼩的两个树跟节点是s1和s2；删除是指将节点s1和s2的双亲改为⾮0；合并就是将s1和s2的权值和作为⼀个新节点的权值依次存⼊到数组的第n+1之后的单元中，同时记录这个新节点左孩⼦的下标为s1，右孩⼦的下标为s2。

数据结构哈夫曼树编码

数据结构哈夫曼树编码一、引言二、哈夫曼树的定义1. 节点的概念2. 哈夫曼树的定义三、哈夫曼编码的概念1. 编码方式2. 码长和平均码长四、哈夫曼编码的实现方法1. 构建哈夫曼树a. 构建思路及步骤b. 构建示例图解2. 编码过程a. 编码步骤及示例图解b. 编码实现代码示例3. 解码过程a. 解码步骤及示例图解b. 解码实现代码示例五、哈夫曼编码的优缺点1. 优点2. 缺点六、应用实例七、总结一、引言：随着信息技术的飞速发展，数据处理已经成为当今社会中一个不可或缺的部分。

在数据处理中，如何高效地压缩数据是一个非常重要的问题。

而哈夫曼树编码作为一种高效的压缩算法，在数据传输和存储方面有着广泛应用。

二、哈夫曼树的定义：1. 节点的概念：哈夫曼树是一种二叉树，由根节点、左子树和右子树组成。

每个节点可以有零个或两个子节点。

叶子节点是指没有子节点的节点，而非叶子节点则至少有一个子节点。

2. 哈夫曼树的定义：哈夫曼树是一种特殊的二叉树，它的所有叶子节点都带有权值。

对于任意一个哈夫曼树，将其所有叶子节点按照权值从小到大排列，则可得到一组序列W={w1,w2,...,wn}。

哈夫曼树的构建过程就是将这组序列转化为一棵二叉树。

三、哈夫曼编码的概念：1. 编码方式：哈夫曼编码是一种前缀编码方式，即每个字符的编码都不是其他字符编码的前缀。

2. 码长和平均码长：对于一个字符c，其在哈夫曼编码中所占用的位数称为其码长Lc。

而整个字符串的平均码长Lavg则是所有字符在哈夫曼编码中所占用位数之和除以字符串长度n。

四、哈夫曼编码的实现方法：1. 构建哈夫曼树a. 构建思路及步骤：（1）将所有字符按照权值从小到大排序，构成初始节点集合。

（2）从节点集合中选出两个权值最小的节点作为左右子节点，构建一棵新的二叉树，并将该二叉树的根节点插入到节点集合中。

（3）重复步骤2，直到只剩下一个节点为止。

b. 构建示例图解：2. 编码过程a. 编码步骤及示例图解：（1）遍历哈夫曼树，对于每个叶子节点记录其路径上所有非叶子节点的左右分支信息，用0表示左分支，用1表示右分支。

数据结构__课程设计之哈夫曼编码

一、设计思想(一) 哈夫曼树的设计思想对于一组具有确定权值的叶子结点可以构造出多个具有不同带权路径长度的二叉树，其中具有最小带权路径长度的二叉树称作哈夫曼树或最优二叉树。

首先给定n个权值制造n个只含根结点的二叉树，得到一个二叉树林；再在这二叉树林里面找根结点的权值最小和次小的两棵树作成新的二叉树，其中新的二叉树的根结点的权值为左右子根结点权值之和；最后在二叉树林中把组合过的二叉树删除，再重复第二步，直到最后就剩一颗二叉树的时候得到的这棵二叉树就是哈夫曼树。

（二）哈夫曼编码与解码的设计思想在数据通讯中，经常要将传送的文字转换为二进制字符0和1组成的二进制串，称这个过程为编码。

与子相对的是解码或是译码，就是用与编码相同的方式将二进制串转换称编码前的文字的过程称作解码。

在这里是通过哈夫曼树实现编码与解码的，所以称作是哈夫曼编码与解码。

首先输入一个字符串，还有相应的在哈夫曼树里的权值，这样用哈夫曼树把字符串用二进制串代替它，这个过程要注意树和编码问题，其中树的问题在上面已经解决，主要看编码的问题，就是根据我们输入的字符串和权值建立相应的树模型，这一步完成那编码就已经完成了，最后打印就行了；然后就是解码，完成编码相应的解码就相对简单了，就是先找到在编码的时候建的那个模型树，将编码中的二进制串再根据权值转换为相应的字符串，这样一步步解码就行了。

以上就是通过用哈夫曼树进行哈夫曼编码与解码如何实现的主要设计思想。

二、算法流程图（一）哈夫曼树的流程图不是图1哈夫曼树的流程图（二）编码的流程图（三）解码的流程图哈夫曼编码与解码的实现- 3 -否三、源代码下面给出的是用中缀转后缀算法实现的程序的源代码：#include "stdio.h" #include "string.h" #define MAX 100/*定义常量*/struct HaffNode {int weight;/*权值*/ int parent;/*双亲结点下标*/char ch; int lchild; int rchild;}*myHaffTree; /*构造哈夫曼树*/struct Coding {char bit[MAX];/*定义数组*/char ch; int weight;/*字符的权值*/}*myHaffCode;/*定义结构体*/void Haffman(int n)/*定义哈夫曼函数*/{int i,j,x1,x2,s1,s2;for (i=n+1;i<=2*n-1;i++) /*树的初始化*/{s1=s2=10000;x1=x2=0;for (j=1;j<=i-1;j++) /*构造哈夫曼树的非叶子结点*/{if(myHaffTree[j].parent==0&&myHaffTree[j].weight<s1) /*分配左右结点*/ {s2=s1;x2=x1;s1=myHaffTree[j].weight;x1=j;}else if(myHaffTree[j].parent==0&&myHaffTree[j].weight<s2){s2=myHaffTree[j].weight;x2=j;}}myHaffTree[x1].parent=i;myHaffTree[x2].parent=i;myHaffTree[i].weight=s1+s2; /*左右子组合为新树*/myHaffTree[i].lchild=x1;myHaffTree[i].rchild=x2;}}void HaffmanCode(int n) /*构造n个结点哈夫曼编码*/{int start,c,f,i,j,k;char *cd;cd=(char *)malloc(n*sizeof(char));myHaffCode=(struct Coding *)malloc((n+1)*sizeof(struct Coding));cd[n-1]='\0';for(i=1;i<=n;++i) /*n个叶子结点的哈夫曼编码*/{start=n-1;for(c=i,f=myHaffTree[i].parent;f!=0;c=f,f=myHaffTree[f].parent)if(myHaffTree[f].lchild==c) cd[--start]='0';else cd[--start]='1';for(j=start,k=0;j<n;j++){myHaffCode[i].bit[k]=cd[j];k++;}myHaffCode[i].ch=myHaffTree[i].ch; /*取编码对应的权值*/ myHaffCode[i].weight=myHaffTree[i].weight;}哈夫曼编码与解码的实现free(cd);}Init() /*定义有返回值的函数*/ {int i,n,m;printf("please input the number of words:");scanf("%d",&n);m=2*n-1;myHaffTree=(struct HaffNode *)malloc(sizeof(struct HaffNode)*(m+1));for(i=1;i<=n;i++){printf("please input the word and the equal:");scanf("%s%d",&myHaffTree[i].ch,&myHaffTree[i].weight);myHaffTree[i].parent=0;myHaffTree[i].lchild=0;myHaffTree[i].rchild=0;}for(i=n+1;i<=m;i++){myHaffTree[i].ch ='#';myHaffTree[i].lchild=0;myHaffTree[i].parent=0;myHaffTree[i].rchild=0;myHaffTree[i].weight=0;}Haffman(n);HaffmanCode(n);for(i=1;i<=n;i++){printf("%c %d",myHaffCode[i].ch,myHaffCode[i].weight);printf("\n");}printf("init success!\n");return n;}void Caozuo_C(int m) /* 编码函数*/{int n,i,j;char string[50],*p;printf("please input the words：");scanf("%s",string);n=strlen(string); /*计算字符串长度*/for(i=1,p=string;i<=n;i++,p++) /*进行编码*/- 5 -{for(j=1;j<=m;j++)if(myHaffCode[j].ch==*p)printf("%s\n",myHaffCode[j].bit);}}void Caozuo_D(int n) /*解码函数*/{int i,c;char code[1000],*p;printf("please input the coding："); /*输入二进制编码*/ scanf("%s",code);for(p=code,c=2*n-1;*p!='\0';p++) /*进行解码*/{if(*p=='0') /*结束条件*/ {c=myHaffTree[c].lchild; /*赋值*/if(myHaffTree[c].lchild==0) /* 扫描*/{printf("%c",myHaffTree[c].ch);c=2*n-1;continue; /*结束*/}}else if(*p=='1'){c=myHaffTree[c].rchild;if(myHaffTree[c].lchild==0){printf("%c",myHaffTree[c].ch);c=2*n-1; /*赋值*/continue;}}}printf("\n");}void main(){int n;char char1; /*定义字符*/n=Init(); /*函数的调用*/哈夫曼编码与解码的实现printf("A.coding B.codeprinting C.exit\nplease input the process:\n");while(1){scanf("%c",&char1);if(char1=='c') /*判断字符*/break;switch(char1){case'A':Caozuo_C(n);break; /*执行编码操作*/case'B':Caozuo_D(n);break; /*执行解码操作*/case'C':;break;}}}四、运行结果（一）中缀转后缀算法的运行结果：- 7 -五、遇到的问题及解决这部分我主要遇到了如下三个问题，其内容与解决方法如下所列：问题1:刚开始不知道如何建一个好树，因为我开始试着建了几个二叉树，不知道什么原因运行的时候那编码总是不对，跟在草稿纸上自己画的那个二叉树总是不相符，就找原因。

数据结构课程设计哈夫曼编码译码器

题目一: 哈夫曼编码与译码一、任务设计一个运用哈夫曼算法的编码和译码系统, 反复地显示并解决以下项目, 直到选择退出为止。

规定：1) 将权值数据存放在数据文献(文献名为data.txt, 位于执行程序的当前目录中) ；2) 初始化：键盘输入字符集记录字符权值、自定义26个字符和26个权值、记录文献中一篇英文文章中26个字母, 建立哈夫曼树；3) 编码: 运用建好的哈夫曼树生成哈夫曼编码；4) 输出编码（一方面实现屏幕输出, 然后实现文献输出）；5）译码（键盘接受编码进行译码、文献读入编码进行译码）；6) 界面优化设计。

二、流程图三、代码分解 //头文献 #include<stdio.h> #include<string.h> #include<stdlib.h> #include <conio.h> #define N 1000 #define M 2*N-1 #define MAXcode 6000 //函数声明void count(CHar &ch,HTNode ht[]);void editHCode(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); //编码函数void printyima(HTNode ht[],HCode hcd[],int n,char bianma[]); //译码函数 void creatHT(HTNode ht[],int n);字符集记录符集记录权值权值至文献“哈夫曼树。

t xt” 菜单1.从键盘输入字符集进行编码2.从文献读入字符集进行编码1.从键盘输入编码进行译码2.从文献读入编码进行译码0.返回上级菜单 0.返回上级菜单void CreateHCode (HTNode ht[],HCode hcd[],int n);void DispHCode(HTNode ht[],HCode hcd[],int n);void input_key(CHar &ch);void input_file(CHar &ch);void input_cw(HTNode ht[]);void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]);void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]);void creat_cw();void bianmacaidan();void yimacaidan();void bianmayima();int caidan();//结构体typedef struct{char data;int parent;int weight;int lchild;int rchild;}HTNode;typedef struct{char cd[N];int start;}HCode;typedef struct{char s[N];int num;}CHar;CHar ch;HTNode ht[M];HCode hcd[N];//主函数int main(){int xh;while(1){system("color 1f"); //操作菜单背景颜色 xh=caidan(); //调用菜单函数switch(xh) //switch语句 {case 1:system("cls");creat_cw();break;case 2:system("cls");creatHT(ht,n);break;case 3:system("cls");CreateHCode(ht,hcd,n);DispHCode(ht,hcd,n);break;case 4:system("cls");bianmayima();break;case 0:system("cls");printf("\n\n\n\n\n\n\n\n\n\t\t\t\t感谢使用本系统!\n\n\n\n\n\n\n \t\t\t");exit(0);default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}return 0;}//菜单函数int caidan() //菜单函数模块//{int xh;printf("\n\n\n");printf("\t\t 欢迎使用哈夫曼编码译码系统\n");printf("\t\t \n");printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n");printf("\t\t*= =*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n");printf("\t\t*= 1.建立字符权值=*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 2.建立并输出哈夫曼树=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 3.生成并查看哈夫曼编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 4.编码与译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 0.退出系统=*\n"); printf("\t\t*= =*\n"); printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d", &xh);return xh; //返回从键盘接受的选项}void bianmayima(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码与译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n");printf("\t\t*= 1.编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianmacaidan();break;case 2:system("cls");yimacaidan();break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void yimacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");yima1(ht,hcd,n,bianma);break;case 2:system("cls");yima2(ht,hcd,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void bianmacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入字符集编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入文章编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianma1(ht,hcd,ch,n,bianma);break;case 2:system("cls");bianma2(ht,hcd,ch,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void creat_cw(){int xh2;while(1){printf("\n\n\n\n\n");printf("\t\t 建立字符权值\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.从键盘输入字符集进行记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.从文献读入字符集记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 3.自定义字符权值=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh2);switch(xh2) //switch语句{case 1:system("cls");input_key(ch);break;case 2:system("cls");input_file(ch);break;case 3:system("cls");input_cw(ht);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}//建立字符权值模块void input_key(CHar &ch){int i,j=0;char st[N];printf("请输入字符集（以‘#’结束）:\n");for(i=0;i<N;i++){scanf("%c",&st[i]);if(st[i]=='#'){st[i]='\0';break;}}strcpy(ch.s,st);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_file(CHar &ch){int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的字符集为:%s\n",ch.s);fclose(fp);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_cw(HTNode ht[]){int i,w,s,j;char a;printf("要输入的字符总个数是？:");scanf("%d",&s);n=s;printf("请输入字符及其权值:\n");for(i=0;i<s;i++){printf("请输入第%d个字母:",i+1);scanf("%s",&a);ht[i].data=a;printf("请输入其权值:");scanf("%d",&w);ht[i].weight=w;}FILE *fp;if((fp=fopen("data.txt","w"))==0){printf("\n\t\t文献打开失败");return;}printf("\n定义权值成功!\n\n");printf("各字符及其权值为:\n\n");fprintf(fp,"各字符及其权值为:\n");printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<i;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight); }printf("\n");printf("\n字符权值已输出至文献“data.txt”！");fclose(fp);printf("输入完毕, 按任意键返回！");getch();system("cls");return;}//记录字符权值函数void count(CHar &ch,HTNode ht[]){int i,j,m=0;char c[N];int sum[N]={0};for(i=0;ch.s[i]!='\0';i++){for(j=0;j<m;j++)if(ch.s[i]==c[j]||(c[j]>='a'&&c[j]<='z'&&ch.s[i]+32==c[j])) break;if(j<m)sum[j]++;else{if(ch.s[i]>='A'&&ch.s[i]<='Z')c[j]=ch.s[i]+32;else c[j]=ch.s[i];sum[j]++;m++;}}for(i=0;i<m;i++){ht[i].data=c[i];ht[i].weight=sum[i];}n=m;FILE *fp;if((fp=fopen("data.txt","w"))==0) {printf("\n\t\t文献打开失败"); return;}printf("\n记录权值成功!\n\n"); printf("各字符及其权值为:\n\n"); fprintf(fp,"各字符及其权值为:\n"); printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<m;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight);}printf("\n");printf("\n字符权值已输出至文献“data.txt”！");fclose(fp);}//构造哈夫曼树void creatHT(HTNode ht[],int n){FILE *fp;if((fp=fopen("哈夫曼树.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,j,k,lnode,rnode;int min1,min2;for (i=0;i<2*n-1;i++)ht[i].parent=ht[i].lchild=ht[i].rchild=-1;for (i=n;i<2*n-1;i++){min1=min2=32767;lnode=rnode=-1;for(k=0;k<=i-1;k++)if(ht[k].parent==-1){if (ht[k].weight<min1){min2=min1;rnode=lnode;min1=ht[k].weight;lnode=k;}else if(ht[k].weight<min2){min2=ht[k].weight;rnode=k;}}ht[lnode].parent=i;ht[rnode].parent=i;ht[i].weight=ht[lnode].weight+ht[rnode].weight;ht[i].lchild=lnode;ht[i].rchild=rnode;}printf("建立huffman树成功!\n");printf("输出huffman树:\n");fprintf(fp,"输出huffman树:\n");printf("\t字符\t权值\t父节点\t 左子节点\t右子节点");fprintf(fp,"\t字符\t权值\t父节点\t 左子节点\t右子节点");for(j=1;j<i;j++){ printf("\n");fprintf(fp,"\n");printf("\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,ht[i]. lchild,ht[j].rchild);fprintf(fp,"\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,h t[i].lchild,ht[j].rchild);}printf("\n");printf("哈夫曼树已输出至文献“哈夫曼树.txt”！按任意键返回!");fclose(fp);getch();system("cls");return;}//生成哈夫曼编码void CreateHCode (HTNode ht[],HCode hcd[],int n){int i,f,c,j=0;HCode hc;for(i=0;i<n;i++){hc.start=n;c=i;hc.cd[hc.start--]='0';f=ht[i].parent;while(f!=-1){if (ht[f].lchild==c)hc.cd[hc.start--]='0';elsehc.cd[hc.start--]='1';c=f;f=ht[f].parent;}hc.start++;for(j=0;j<hc.start;j++)hc.cd[j]=' ';hcd[i]=hc;}}void DispHCode(HTNode ht[],HCode hcd[],int n) {FILE *fp;if((fp=fopen("哈夫曼编码.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,k;int sum=0,m=0,j;printf("输出字符哈夫曼编码:\n"); fputs("输出字符哈夫曼编码:\n",fp); for (i=0;i<n;i++){j=0;printf("%c:\t",ht[i].data);fprintf(fp,"\n%c:\t",ht[i].data);for (k=hcd[i].start;k<=n;k++){printf("%c",hcd[i].cd[k]);j++;fprintf(fp,"%c",hcd[i].cd[k]); }m+=ht[i].weight;sum+=ht[i].weight*j;printf("\n");}printf("\n哈夫曼编码已保存至文献“哈夫曼编码.txt!按任意键返回！”");fclose(fp);getch();system("cls");}//编码函数void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]){int i;char str[N];printf("请输入要编码的字符集（以‘#’结束）:\n");for(i=0;i<N;i++){scanf("%c",&str[i]);if(str[i]=='#'){str[i]='\0';break;}}strcpy(ch.s,str);ch.num=strlen(str);editHCode(ht,hcd,ch,n,bianma);getch();system("cls");}void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}ch.num=strlen(ch.s);printf("\n读入成功!\n");printf("文献中的字符集为:\n%s",ch.s);fclose(fp);editHCode(ht,hcd,ch,n,bianma);system("cls");return;}//译码函数void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;char code[MAXcode];printf("请输入编码进行译码（以‘#’结束）:\n");for(i=0;i<MAXcode;i++){scanf("%c",&code[i]);if(code[i]=='#'){code[i]='\0';break;}}strcpy(bianma,code);printyima(ht,hcd,n,bianma);printf("\n译码完毕！按任意键返回!");getch();system("cls");return;}void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&bianma[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的编码是:%s\n",bianma);printyima(ht,hcd,n,bianma);printf("\n译码完毕！按任意键返回!");getch();system("cls");}四、调试结果主菜单建立字符权值选择2.从文献读入字符进行记录输入测试文献名“cs.txt”输出个字符权值建立哈夫曼树并输出至文献生成哈夫曼编码并保存至文献编码选择2.从文献读入字符集编码编码结果保存至文献译码选择2.从文献读入编码, 读入上一步的编码译码完毕, 返回！退出系统。

数据结构——哈夫曼（Huffman）树+哈夫曼编码

数据结构——哈夫曼（Huffman）树+哈夫曼编码前天acm实验课，⽼师教了⼏种排序，抓的⼀套题上有⼀个哈夫曼树的题，正好之前离散数学也讲过哈夫曼树，这⾥我就结合课本，整理⼀篇关于哈夫曼树的博客。

哈夫曼树的介绍Huffman Tree，中⽂名是哈夫曼树或霍夫曼树，它是最优⼆叉树。

定义：给定n个权值作为n个叶⼦结点，构造⼀棵⼆叉树，若树的带权路径长度达到最⼩，则这棵树被称为哈夫曼树。

这个定义⾥⾯涉及到了⼏个陌⽣的概念，下⾯就是⼀颗哈夫曼树，我们来看图解答。

(01) 路径和路径长度定义：在⼀棵树中，从⼀个结点往下可以达到的孩⼦或孙⼦结点之间的通路，称为路径。

通路中分⽀的数⽬称为路径长度。

若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。

例⼦：100和80的路径长度是1，50和30的路径长度是2，20和10的路径长度是3。

(02) 结点的权及带权路径长度定义：若将树中结点赋给⼀个有着某种含义的数值，则这个数值称为该结点的权。

结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。

例⼦：节点20的路径长度是3，它的带权路径长度= 路径长度 * 权 = 3 * 20 = 60。

(03) 树的带权路径长度定义：树的带权路径长度规定为所有叶⼦结点的带权路径长度之和，记为WPL。

例⼦：⽰例中，树的WPL= 1*100 + 2*50 +3*20 + 3*10 = 100 + 100 + 60 + 30 = 290。

⽐较下⾯两棵树上⾯的两棵树都是以{10, 20, 50, 100}为叶⼦节点的树。

左边的树WPL=2*10 + 2*20 + 2*50 + 2*100 = 360 右边的树WPL=350左边的树WPL > 右边的树的WPL。

你也可以计算除上⾯两种⽰例之外的情况，但实际上右边的树就是{10,20,50,100}对应的哈夫曼树。

⾄此，应该堆哈夫曼树的概念有了⼀定的了解了，下⾯看看如何去构造⼀棵哈夫曼树。

数据结构哈夫曼编码

数据结构哈夫曼编码
哈夫曼编码是一种用于数据压缩的算法，它基于哈夫曼树（HuffmanTree）进行编码。

哈夫曼编码的基本思想是：对于出现频率高的字符，其编码长度较短；而对于出现频率低的字符，其编码长度较长。

这样，通过调整字符的编码长度，可以有效地压缩数据。

哈夫曼编码的具体步骤如下：
1.统计原始数据中每个字符的出现频率。

2.构建哈夫曼树。

在构建过程中，每次将两个权值最小的节点合并，并将它们的权值相加。

同时，将新生成的节点的权值作为新字符的出现频率。

3.根据哈夫曼树生成哈夫曼编码。

对于哈夫曼树中的每个字符，从根节点到该字符所在节点的路径可以形成一个二进制编码。

通常约定左分支标记为0，右分支标记为1。

这样，从根节点到每个叶节点的路径就可以形成一个二进制编码，该编码即为对应字符的哈夫曼编码。

4.使用哈夫曼编码对原始数据进行压缩。

对于原始数据中的每个字符，根据其哈夫曼编码进行编码，最终得到压缩后的数据。

需要注意的是，哈夫曼编码是一种无损压缩算法，即压缩和解压过程中可以完全还原原始数据。

同时，由于哈夫曼编码是基于字符出现频率进行编码的，因此对于出现频率高的字符，其编码长度较短；而对于出现频率低的字符，其编码长度较长。

这样可以有效地减少数据的存储空间，提高数据压缩率。

哈夫曼编码译码器数据结构C语言

哈夫曼编码译码器数据结构C语言哈夫曼编码译码器数据结构C语言引言哈夫曼编码是一种用于无损数据压缩的编码方式，它利用出现频率较高的字符使用较短的编码，而出现频率较低的字符使用较长的编码。

通过这种方式可以使得编码后的数据占据较少的存储空间。

本文将介绍如何使用C语言实现一个哈夫曼编码译码器的数据结构。

哈夫曼树哈夫曼树是哈夫曼编码的关键数据结构，它可以通过给定的字符频率构建出一棵树。

在哈夫曼树中，每个字符都有一个对应的叶子节点，而非叶子节点表示编码的中间过程。

具体构建哈夫曼树的步骤如下：1. 统计每个字符的出现频率。

2. 将每个字符及其频率构建成一个节点，并按照频率从小到大排序。

3. 从频率最小的两个节点开始，合并成一个新节点，并将新节点的频率设为两个节点频率之和。

4. 将新节点插入到节点列表中，保持节点列表有序。

5. 重复步骤3和步骤4，直到只剩下一个节点，这个节点就是哈夫曼树的根节点。

编码在构建了哈夫曼树之后，我们可以根据树的结构来进行编码。

对于每个字符，其编码是由根节点到对应叶子节点路径上的边来表示的。

具体编码的步骤如下：1. 从根节点开始，递归遍历哈夫曼树的每个节点。

2. 如果当前节点为叶子节点，记录下从根节点到该叶子节点所经过的路径上的边的取值（0表示左边，1表示右边），得到该字符的编码。

3. 对于每个字符，将其编码存储起来以便后续使用。

译码译码的过程与编码相反，我们可以根据编码来找到对应的字符。

具体译码的步骤如下：1. 从哈夫曼树的根节点开始，逐个读取待译码的数据。

2. 如果读取的数据为0，移动到左子节点；如果读取的数据为1，移动到右子节点。

3. 如果移动到了叶子节点，记录下该叶子节点对应的字符，并回到根节点。

4. 重复步骤2和步骤3，直到读取完毕所有的数据，得到原始的字符序列。

实现下面是一个用C语言实现的哈夫曼编码译码器的数据结构示例：```cinclude <stdio.h>typedef struct Node {char character;int frequency;struct Node left;struct Node right;} Node;typedef struct HuffmanTree {Node root;} HuffmanTree;HuffmanTree buildHuffmanTree(char characters, int frequencies, int size) {// 构建哈夫曼树的代码实现}void encode(HuffmanTree tree, char string, char encodedString) {// 编码的代码实现}void decode(HuffmanTree tree, char encodedString, char decodedString) {// 译码的代码实现}int mn() {// 测试代码}```总结通过本文，我们了解了哈夫曼编码译码器的数据结构及其在C 语言中的实现。

数据结构哈夫曼编码

数据结构哈夫曼编码
哈夫曼编码是一种用于数据压缩的编码方式，通过将出现频率高的字符编码为较短的二进制码，而将出现频率低的字符编码为较长的二进制码，从而减少数据的存储空间。

哈夫曼编码的具体过程如下：
1. 统计待编码的字符出现的频率。

2. 按照频率构建一个字符节点的最小堆（也可以使用优先队列），其中频率小的节点具有较高的优先级。

3. 从最小堆中取出频率最小的两个节点，并创建一个新节点作为它们的父节点，新节点的频率是两个子节点的频率之和。

4. 将新节点插入到最小堆中。

5. 重复步骤3和4，直到堆中只剩下一个节点。

6. 从根节点开始，为每个字符赋予一个唯一的二进制编码，如果向左移动表示0，向右移动表示1。

7. 使用所得的编码对原始数据进行替换。

通过哈夫曼编码，字符出现频率高的会被赋予较短的编码，而出现频率低的则会被赋予较长的编码，从而实现了数据的压缩。

在解码时，根据编码的规则，通过树的遍历将二进制编码还原为原始的字符。

哈夫曼编码在数据压缩、数据传输和通信领域被广泛应用。

它是一种无损压缩算法，可以减小数据的存储空间并保持数据的完整性。

PTA数据结构哈夫曼树与哈夫曼编码

PTA数据结构哈夫曼树与哈夫曼编码⽂章⽬录题⽬描述题⽬背景:介绍什么是哈夫曼树和哈夫曼编码, 不影响做题哈夫曼树(Huffman Tree)⼜称最优⼆叉树，是⼀种带权路径长度最短的⼆叉树。

所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。

树的路径长度是从树在数据通信中，需要将传送的⽂字转换成⼆进制的字符串，⽤0，1码的不同排列来表⽰字符。

例如，需传送的报⽂为“AFTER DATA EAR ARE ART AREA”，这⾥⽤到的字符集为“A，E，R，T，F，D”，各字母出现的次数为{8，4，5，3，1，1}。

现要为使不等长编码为前缀编码(即要求⼀个字符的编码不能是另⼀个字符编码的前缀)，可⽤字符集中的每个字符作为叶⼦结点⽣成⼀棵编码⼆叉树，为了获得传送报⽂的最短长度，可将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使⽤本题要求从键盘输⼊若⼲电⽂所⽤符号及其出现的频率，然后构造哈夫曼树，从⽽输出哈夫曼编码。

注意：为了保证得到唯⼀的哈夫曼树，本题规定在构造哈夫曼树时，左孩⼦结点权值不⼤于右孩⼦结点权值。

如权值相等，则先选优先级队列中先出队的节点。

编码时，左分⽀取“0”，右分⽀取“1”。

输⼊格式输⼊有3⾏第1⾏：符号个数n（2～20）第2⾏：⼀个不含空格的字符串。

记录着本题的符号表。

我们约定符号都是单个的⼩写英⽂字母，且从字符‘a’开始顺序出现。

也就是说，如果 n 为 2 ，则符号表为 ab；如果 n 为 6，则符号为 abcdef；以此类推。

第3⾏：各符号出现频率（⽤乘以100后的整数），⽤空格分隔。

输出格式先输出构造的哈夫曼树带权路径长度。

接下来输出n⾏，每⾏是⼀个字符和该字符对应的哈夫曼编码。

字符按字典顺序输出。

字符和哈夫曼编码之间以冒号分隔。

样例输⼊:8abcdefgh5 29 7 8 14 23 3 11输出:271a:0001b:10c:1110d:1111e:110f:01g:0000h:001⼀点说明关于题⽬描述中的"如权值相等，则先选优先级队列中先出队的节点"可以参考上图, 权值为7的节点选择了权值为8的叶⼦节点, ⽽不是权值为8的⼦树感觉题⽬想表达的意思是, 若权值相等，则先选优先级队列中先⼊队的节点(如有错误, 望指正)想法利⽤优先队列维护⼩根堆(因为建树时,要选两个权值最⼩的),利⽤哈夫曼算法建树,再根据所建哈夫曼树,利⽤深搜回溯,得到各个字符的哈夫曼编码和树的带权路径长度实现#include <cstdio>#include <iostream>#include <string>#include <queue>#include <vector>using namespace std;struct node{int weight;char ch = 'z' + 1; // 这样在优先队列⾃定义排序时, 可以做到权值相等,则先选优先级队列中先出队的节点node *lchild, *rchild;};// ⾃定义优先队列的排序⽅式, 权值⼩优先, 权值相等,则先选优先级队列中先出队的节点struct cmp{bool operator() (node* a, node* b){if(a->weight == b->weight)return a->ch > b->ch;return a->weight > b->weight;}};int n, WPL; // n:结点数 WPL:树的带权路径长度(⾮叶⼦节点的权值和)string str;priority_queue<node, vector<node*>, cmp> q; //vector<char> ans[100]; // 存放哈夫曼编码vector<char> code; // ⽤于深搜得到哈夫曼编码node* createTree() // 建⽴哈夫曼树{node* r;while(!q.empty()){if(q.size() == 1){node* a = q.top();q.pop();r = a;break;}else{node* a = q.top();q.pop();node* b = q.top();q.pop();node* c = new node();c->weight = a->weight + b->weight;c->lchild = a;c->rchild = b;r = c;q.push(c);}}return r;}void print() // 输出前缀编码{cout << WPL << endl;for(int i=0; i<n; i++){cout << str[i] << ":";int index = str[i] - 'a';for(int j=0; j<ans[index].size(); j++)cout << ans[index][j];cout << endl;}}void dfs(node* root) // 深搜回溯得到哈夫曼编码和树的带权路径长度{if(root->lchild != NULL || root->rchild != NULL)WPL += root->weight; // WPL即⾮叶⼦节点的权值之和if(root->lchild == NULL && root->rchild == NULL){char ch = root->ch;ans[ch-'a'] = code; // 根据叶⼦节点的字符, 判断是谁的哈夫曼编码return;}if(root->lchild != NULL){code.push_back('0');dfs(root->lchild);code.pop_back(); // 回溯}if(root->rchild != NULL){code.push_back('1');dfs(root->rchild);code.pop_back(); // 回溯}return;}int main(){cin >> n;cin >> str;for(int i=0; i<n; i++) // 读⼊各节点的权值, 利⽤优先队列维护⼩根堆, 便于建树{node* temp = new node(); // 不要忘记给指针分配空间cin >> temp->weight;temp->ch = str[i];temp->lchild = temp->rchild = NULL;q.push(temp);}node* root = createTree(); // 建⽴哈夫曼树dfs(root); // 回溯得到哈夫曼编码及WPLprint();return 0;}。

数据结构哈夫曼树和哈夫曼编码权值

主题：数据结构——哈夫曼树和哈夫曼编码权值1. 引言在计算机科学中，对于大规模的数据存储和传输，有效地压缩数据是一项重要的任务。

哈夫曼树和哈夫曼编码权值是一种经典的数据结构和算法，用于实现数据的高效压缩和解压缩。

本文将介绍哈夫曼树和哈夫曼编码权值的概念和原理，探讨其在数据压缩中的应用以及个人对该主题的理解。

2. 哈夫曼树2.1 概念哈夫曼树，又称最优二叉树，是一种具有最小带权路径长度的二叉树。

树的带权路径长度定义为树中所有叶子节点的权值乘以其到根节点的距离，即路径长度的总和。

2.2 构造方法哈夫曼树的构造方法是一种贪心算法。

将所有的权值作为叶子节点构建n棵单节点树。

从这些树中选择两棵权值最小的树合并，得到一棵新的树，新树的根节点的权值为这两棵树根节点权值之和。

重复此过程，直到只剩下一棵树，即为哈夫曼树。

2.3 例子以数据集[7, 5, 2, 4]为例，构造哈夫曼树的过程如下： 1. 初始状态下，将每个权值看作一棵树：7、5、2、4。

2. 选择两棵权值最小的树2和4进行合并，得到一棵新树，根节点的权值为2+4=6。

此时，剩下的树为6、5、7。

3. 选择两棵权值最小的树5和6进行合并，得到一棵新树，根节点的权值为5+6=11。

此时，剩下的树为11、7。

4. 选择两棵权值最小的树7和11进行合并，得到一棵新树，根节点的权值为7+11=18。

得到最终的哈夫曼树。

3. 哈夫曼编码权值3.1 概念哈夫曼编码权值是指在哈夫曼树中，从根节点到每个叶子节点的路径上所经过的边的权值。

对于哈夫曼树中的每个字符（叶子节点），都可以通过从根节点到叶子节点的路径上的边的权值，来进行编码。

3.2 编码方法哈夫曼编码方法的基本原则是将出现频率高的字符用较短的编码表示，出现频率低的字符用较长的编码表示。

在哈夫曼树中，根节点到左子树的路径上的边标记为0，到右子树的路径上的边标记为1。

通过遍历哈夫曼树，可以分配每个字符的编码。

数据结构考试-哈夫曼编码特辑

能求哈夫曼树、哈夫曼编码，能求平均编码长度哈夫曼树：举个例子有个序列是(7,9,2,6,32,3,21,10)叫你求哈夫曼树注意：一般小的数放左边，大的放右边。

左右节点可以互换的，编码也有不同。

哈夫曼编码没有唯一性的，它的目的是用最短的代价去表示一系列数。

步骤一：把这些点都看成是一个只有根结点的树的集合F步骤二，选2个值最小的树步骤三：在这些树的集合F中删除这2棵树然后把构成一颗二叉树变成了（5 = 2 + 3）然后把这个树加入到集合F5代表这棵树的权值然后继续上述步骤肯定是选5 和6把这2个构成二叉树在F中删除5 6 加入11这棵树变成了继续上述步骤选7 和 9在F中删除7 和9加入16这棵树变成了继续上述步骤选10 和11在F中删除10 和11 加入21这棵树继续上述步骤选16和21 （有2个21，随便选哪个）我选那个只有一个根结点的21好了16和21构成二叉树在F中删除这16和21这两棵树加入37这棵树继续上述步骤选21和32构成二叉树在F中删除21和32这2两棵树加入53这棵树还是继续上面步骤把F 中的两棵树合并成一棵树完成了!这个就是哈夫曼树哈夫曼编码：以上图结果为例，左边为0，右边为1，进行编码，结果如下图：{7,9,2,6,32,3,21,10}编码为：7的编码为0009的编码为0012的编码为101006的编码为101132的编码为113的编码为1010121的编码为0110的编码为100以上述结果为例，如果题目为：要输出的字符集D={A,B,C,D,E,F,G,H}字符出现频率w={0.07,0.09,0.02,0.06,0.32,0.03,0.21,0.10} 对应编码就是：(A)0.07的编码为000(B)0.09的编码为001(C)0.02的编码为10100(D)0.06的编码为1011(E)0.32的编码为11(F)0.03的编码为10101(G)0.21的编码为01(H)0.10的编码为100以上述结果为例，求平均编码长度：3*0.07+3*0.09+5*0.02+4*0.06+2*0.32+5*0.03+2*0.21+3*0.10=2.33以3*0.07为例，0.07为频率w里面的0.07，因为编码是000，有3位数，所以是3。

哈夫曼树题目集408

哈夫曼树题目集408
哈夫曼树是一种用于数据压缩和编码的数据结构，常见于无损压缩算法中。

这里是一份哈夫曼树题目集，供大家练习。

1. 给定一组权值，构造对应的哈夫曼树。

2. 给定一组二进制编码和对应的权值，构造对应的哈夫曼树。

3. 给定一个哈夫曼树和一个字符串，将字符串编码成二进制字符串。

4. 给定一个哈夫曼树和一个二进制字符串，将其解码成原始字符串。

5. 给定一组权值和一个目标平均编码长度，求对应的哈夫曼树所需要的最小权值。

6. 给定一组权值和一个目标最大编码长度，求对应的哈夫曼树所需要的最小权值。

7. 给定一个哈夫曼树和一个二进制字符串，求该字符串的前缀码是否为哈夫曼编码。

8. 给定一个哈夫曼树和一个字符串，求该字符串是否可以被哈夫曼编码。

9. 给定一组权值和一个目标平均编码长度，求对应的哈夫曼编码的平均编码长度。

10. 给定一组权值和一个目标最大编码长度，求对应的哈夫曼编码的最大编码长度。

以上这些题目可以帮助大家熟悉哈夫曼树的基本操作和应用，提
高编程能力。

哈夫曼编码数据结构

哈夫曼编码是一种编码方式，它使用变长编码来表示给定字符集中字符的序列。

它基于一种叫做哈夫曼树的数据结构，它通过将每个字符与一个编码树上的节点相关联来实现编码。

哈夫曼树由若干个叶节点和中间节点组成，每个叶节点包含一个字符和一个权重值，而中间节点包含两个子节点和一个权重值。

权重值是指字符或子节点的频率。

叶节点的权重值是字符的频率，中间节点的权重值是其子节点的权重值之和。

哈夫曼树的构造需要将每个字符和其对应的权重值放入一个优先队列中，每次从优先队列中取出两个最小权重值的节点，将它们作为孩子节点构成新的节点，并将新节点的权重值设为两个孩子节点权重值之和，然后将新节点重新插入优先队列。

这个过程会一直重复，直到优先队列中只剩下一个节点，这个节点就是哈夫曼树的根节点。

哈夫曼树可以用来实现变长编码，即每个字符都有一个相对较短的编码，而字符出现的频率越高，其编码就越短。

实现变长编码的方法是从根节点开始，向下
遍历哈夫曼树，每向左走一步就记为“0”，每向右走一步就记为“1”，直到遍历到叶节点，这个路径上的“0”和“1”就是叶节点的编码。

数据结构与算法——树的应用（哈夫曼编码）

数据结构与算法——树的应⽤（哈夫曼编码）1. 哈夫曼编码概括/********************************************** 本⽂图⽚较多，多刷新⼀下才能显⽰ ***********************************************/哈夫曼（Huffman）编码算法是基于⼆叉树构建编码压缩结构的，它是数据压缩中经典的⼀种算法。

算法根据⽂本字符出现的频率，重新对字符进⾏编码。

⾸先以下这段⽂字举例：今天天⽓晴朗，我和乔伊·亚历⼭⼤·⽐基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱⼠·普雷斯顿出去玩！乔伊·亚历⼭⼤·⽐基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱⼠·普雷斯顿贪玩，不⼩⼼摔了⼀跤，乔伊·亚历⼭⼤·⽐基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱⼠·普雷斯顿被摔得哇哇哭了，乔伊·亚历⼭⼤·⽐基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱⼠·普雷斯顿的爸爸闻声赶来，⼜把乔伊·亚历⼭⼤·⽐基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱⼠·普雷斯顿痛扁了⼀阵。

数据结构考试-哈夫曼编码特辑

数据结构：哈夫曼树和哈夫曼编码

数据结构哈夫曼编码加密文件

数据结构 哈夫曼编码

数据结构课程设计哈夫曼编码实验

数据结构C语言哈夫曼编码译码

数据结构哈弗曼编译码———c语言版

数据结构c+python代码6：哈夫曼树构造及编码

数据结构哈夫曼树编码

数据结构__课程设计之哈夫曼编码

数据结构课程设计哈夫曼编码译码器

数据结构——哈夫曼（Huffman）树+哈夫曼编码

数据结构哈夫曼编码

哈夫曼编码译码器数据结构C语言

数据结构 哈夫曼编码

PTA数据结构哈夫曼树与哈夫曼编码

数据结构哈夫曼树和哈夫曼编码权值

数据结构考试-哈夫曼编码特辑

哈夫曼树题目集408

哈夫曼编码数据结构

数据结构与算法——树的应用（哈夫曼编码）

数据结构哈夫曼编码

数据结构哈夫曼编码