哈弗曼数据结构专题实验报告

合集下载

数据结构(C语言版)实验报告(哈夫曼树)

数据结构(C语言版)实验报告(哈夫曼树)

《数据结构与算法》实验报告一、需求分析1.问题描述:利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。

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

对于双工通道(及可以双向传输信息的通道),每端都需要一个完整的编/译码系统。

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

2.基本要求一个完整的系统应具有以下功能:(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中。

3.测试数据(1)利用教科书例6-2中的数据调试程序。

(2)用下表给出的字符集和频度的实际统计数据建立哈夫曼树,并实现以下报文的编码和译码:“THIS PROGRAM IS MY FAVORITE”。

4,实现提示(1)编码结果以文本方式存储在文件CodeFile中。

(2)用户界面可以设计为“菜单”方式:显示上述功能符号,再加上“Q”表示退出运行Quit。

请用户键入一个选择功能符。

此功能执行完毕后再显示此菜单,直至某次用户选择了“Q”为止。

(3)在程序的一次执行过程中,第一次执行I、D或C命令之后,哈夫曼树已经在内存了,不必再读入。

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告一、实验目的:通过哈夫曼编、译码算法的实现,巩固二叉树及哈夫曼树相关知识的理解掌握,训练学生运用所学知识,解决实际问题的能力。

二、实验内容:已知每一个字符出现的频率,构造哈夫曼树,并设计哈夫曼编码。

1、从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树。

2、打印每一个字符对应的哈夫曼编码。

3、对从终端读入的字符串进行编码,并显示编码结果。

4、对从终端读入的编码串进行译码,并显示译码结果。

三、实验方案设计:(对基本数据类型定义要有注释说明,解决问题的算法思想描述要完整,算法结构和程序功能模块之间的逻辑调用关系要清晰,关键算法要有相应的流程图,对算法的时间复杂度要进行分析)1、算法思想:(1)构造两个结构体分别存储结点的字符及权值、哈夫曼编码值:(2)读取前n个结点的字符及权值,建立哈夫曼树:(3)根据哈夫曼树求出哈夫曼编码:2、算法时间复杂度:(1)建立哈夫曼树时进行n到1次合并,产生n到1个新结点,并选出两个权值最小的根结点:O(n²);(2)根据哈夫曼树求出哈夫曼编码:O(n²)。

(3)读入电文,根据哈夫曼树译码:O(n)。

四、该程序的功能和运行结果:(至少有三种不同的测试数据和相应的运行结果,充分体现该程序的鲁棒性)1、输入字符A,B,C,D,E,F及其相应权值16、12、9、30、6、3。

2、输入字符F,E,N,G,H,U,I及其相应权值30、12、23、22、12、7、9。

3、输入字符A,B,C,D,E,F,G,H,I,G及其相应权值19、23、25、18、12、67、23、9、32、33。

数据结构哈夫曼树编码及译码的实现实验报告

数据结构哈夫曼树编码及译码的实现实验报告

实验:哈夫曼树编码及译码的实现一.实验题目给定字符集的HUFFMANN编码与解码,这里的字符集及其字符频数自己定义,要求输出个字符集的哈夫曼编码及给定的字符串的哈夫曼码及译码结果。

二.实验原理首先规定构建哈夫曼树,然后进行哈夫曼树的编码,接着设计函数进行字符串的编码过程,最后进行哈夫曼编码的译码。

首先定义一个结构体,这个结构体定义时尽可能的大,用来存放左右的变量,再定义一个地址空间,用于存放数组,数组中每个元素为之前定义的结构体。

输入n个字符及其权值。

构建哈夫曼树:在上述存储结构上实现的哈夫曼算法可大致描述为:1.首先将地址空间初始化,将ht[0…n-1]中所有的结点里的指针都设置为空,并且将权值设置为0.2.输入:读入n个叶子的权值存于向量的前n个分量中。

它们是初始森林中n个孤立的根结点上的权值。

3.合并:对森林中的树共进行n-1次合并,所产生的新结点依次放入向量ht的第i个分量中。

每次合并分两步:①在当前森林ht[0…i-1]的所有结点中,选取权最小和次小的两个根结点[s1]和 [s2]作为合并对象,这里0≤s1,s2≤i-1。

②将根为ht[s1]和ht[s2]的两棵树作为左右子树合并为一棵新的树,新树的根是新结点ht[i]。

具体操作:将ht[s1]和ht[s2]的parent置为i,将ht[i]的lchild和rchild分别置为s1和s2 .新结点ht[i]的权值置为ht[s1]和ht[s2]的权值之和。

4.哈夫曼的编码:约定左子为0,右子为1,则可以从根结点到叶子结点的路径上的字符组成的字符串作为该叶子结点的编码。

当用户输入字母时。

就在已经找好编码的编码结构体中去查找该字母。

查到该字母就打印所存的哈夫曼编码。

接着就是完成用户输入0、1代码时把代码转成字母的功能。

这是从树的头结点向下查找,如果当前用户输入的0、1串中是0则就走向该结点的左子。

如果是1这就走向该结点的右结点,重复上面步骤。

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1·实验目的1·1 理解哈夫曼编码的基本原理1·2 掌握哈夫曼编码的算法实现方式1·3 熟悉哈夫曼编码在数据压缩中的应用2·实验背景2·1 哈夫曼编码的概念和作用2·2 哈夫曼编码的原理和算法2·3 哈夫曼编码在数据压缩中的应用3·实验环境3·1 硬件环境:计算机、CPU、内存等3·2 软件环境:编程语言、编译器等4·实验过程4·1 构建哈夫曼树4·1·1 哈夫曼树的构建原理4·1·2 哈夫曼树的构建算法4·2 哈夫曼编码4·2·1 哈夫曼编码的原理4·2·2 哈夫曼编码的算法4·3 实现数据压缩4·3·1 数据压缩的概念和作用4·3·2 哈夫曼编码在数据压缩中的应用方法5·实验结果5·1 构建的哈夫曼树示例图5·2 哈夫曼编码表5·3 数据压缩前后的文件大小对比5·4 数据解压缩的正确性验证6·实验分析6·1 哈夫曼编码的优点和应用场景分析6·2 数据压缩效果的评估和对比分析6·3 实验中遇到的问题和解决方法7·实验总结7·1 实验所获得的成果和收获7·2 实验中存在的不足和改进方向7·3 实验对于数据结构学习的启示和意义附件列表:1·实验所用的源代码文件2·实验中用到的测试数据文件注释:1·哈夫曼编码:一种用于数据压缩的编码方法,根据字符出现频率构建树形结构,实现高频字符用较短编码表示,低频字符用较长编码表示。

2·哈夫曼树:由哈夫曼编码算法构建的一种特殊的二叉树,用于表示字符编码的结构。

哈夫曼树_实验报告

哈夫曼树_实验报告

一、实验目的1. 理解哈夫曼树的概念及其在数据结构中的应用。

2. 掌握哈夫曼树的构建方法。

3. 学习哈夫曼编码的原理及其在数据压缩中的应用。

4. 提高编程能力,实现哈夫曼树和哈夫曼编码的相关功能。

二、实验原理哈夫曼树(Huffman Tree)是一种带权路径长度最短的二叉树,又称为最优二叉树。

其构建方法如下:1. 将所有待编码的字符按照其出现的频率排序,频率低的排在前面。

2. 选择两个频率最低的字符,构造一棵新的二叉树,这两个字符分别作为左右子节点。

3. 计算新二叉树的频率,将新二叉树插入到排序后的字符列表中。

4. 重复步骤2和3,直到只剩下一个节点,这个节点即为哈夫曼树的根节点。

哈夫曼编码是一种基于哈夫曼树的编码方法,其原理如下:1. 从哈夫曼树的根节点开始,向左子树走表示0,向右子树走表示1。

2. 每个叶子节点对应一个字符,记录从根节点到叶子节点的路径,即为该字符的哈夫曼编码。

三、实验内容1. 实现哈夫曼树的构建。

2. 实现哈夫曼编码和译码功能。

3. 测试实验结果。

四、实验步骤1. 创建一个字符数组,包含待编码的字符。

2. 创建一个数组,用于存储每个字符的频率。

3. 对字符和频率进行排序。

4. 构建哈夫曼树,根据排序后的字符和频率,按照哈夫曼树的构建方法,将字符和频率插入到哈夫曼树中。

5. 实现哈夫曼编码功能,遍历哈夫曼树,记录从根节点到叶子节点的路径,即为每个字符的哈夫曼编码。

6. 实现哈夫曼译码功能,根据哈夫曼编码,从根节点开始,按照0和1的路径,找到对应的叶子节点,即为解码后的字符。

7. 测试实验结果,验证哈夫曼编码和译码的正确性。

五、实验结果与分析1. 构建哈夫曼树根据实验数据,构建的哈夫曼树如下:```A/ \B C/ \ / \D E F G```其中,A、B、C、D、E、F、G分别代表待编码的字符。

2. 哈夫曼编码根据哈夫曼树,得到以下字符的哈夫曼编码:- A: 00- B: 01- C: 10- D: 11- E: 100- F: 101- G: 1103. 哈夫曼译码根据哈夫曼编码,对以下编码进行译码:- 00101110111译码结果为:BACGACG4. 实验结果分析通过实验,验证了哈夫曼树和哈夫曼编码的正确性。

数据结构 哈夫曼编码实验报告

数据结构 哈夫曼编码实验报告

数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1. 实验目的本实验旨在通过实践理解哈夫曼编码的原理和实现方法,加深对数据结构中树的理解,并掌握使用Python编写哈夫曼编码的能力。

2. 实验原理哈夫曼编码是一种用于无损数据压缩的算法,通过根据字符出现的频率构建一棵哈夫曼树,并根据哈夫曼树对应的编码。

根据哈夫曼树的特性,频率较低的字符具有较长的编码,而频率较高的字符具有较短的编码,从而实现了对数据的有效压缩。

实现哈夫曼编码的主要步骤如下:1. 统计输入文本中每个字符的频率。

2. 根据字符频率构建哈夫曼树,其中树的叶子节点代表字符,内部节点代表字符频率的累加。

3. 遍历哈夫曼树,根据左右子树的关系对应的哈夫曼编码。

4. 使用的哈夫曼编码对输入文本进行编码。

5. 将编码后的二进制数据保存到文件,同时保存用于解码的哈夫曼树结构。

6. 对编码后的文件进行解码,还原原始文本。

3. 实验过程3.1 统计字符频率首先,我们需要统计输入文本中每个字符出现的频率。

可以使用Python中的字典数据结构来记录字符频率。

遍历输入文本的每个字符,将字符添加到字典中,并递增相应字符频率的计数。

```pythondef count_frequency(text):frequency = {}for char in text:if char in frequency:frequency[char] += 1else:frequency[char] = 1return frequency```3.2 构建哈夫曼树根据字符频率构建哈夫曼树是哈夫曼编码的核心步骤。

我们可以使用最小堆(优先队列)来高效地构建哈夫曼树。

首先,将每个字符频率作为节点存储到最小堆中。

然后,从最小堆中取出频率最小的两个节点,将它们作为子树构建成一个新的节点,新节点的频率等于两个子节点频率的和。

将新节点重新插入最小堆,并重复该过程,直到最小堆中只剩下一个节点,即哈夫曼树的根节点。

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验内容本次实验的主要内容是哈夫曼树的创建和编码解码。

二、实验目的1. 理解并掌握哈夫曼树的创建过程;2. 理解并掌握哈夫曼编码的原理及其实现方法;3. 掌握哈夫曼树的基本操作,如求哈夫曼编码和哈夫曼解码等;4. 学习如何组织程序结构,运用C++语言实现哈夫曼编码和解码。

三、实验原理哈夫曼树的创建:哈夫曼树的创建过程就是一个不断合并权值最小的两个叶节点的过程。

具体步骤如下:1. 将所有节点加入一个无序的优先队列里;2. 不断地选出两个权值最小的节点,并将它们合并成为一个节点,其权值为这两个节点的权值之和;3. 将新的节点插入到队列中,并继续执行步骤2,直到队列中只剩下一棵树,这就是哈夫曼树。

哈夫曼编码:哈夫曼编码是一种无损压缩编码方式,它根据字符出现的频率来构建编码表,并通过编码表将字符转换成二进制位的字符串。

具体实现方法如下:1. 统计每个字符在文本中出现的频率,用一个数组记录下来;2. 根据字符出现的频率创建哈夫曼树;3. 从根节点开始遍历哈夫曼树,给左分支打上0的标记,给右分支打上1的标记。

遍历每个叶节点,将对应的字符及其对应的编码存储在一个映射表中;4. 遍历文本中的每个字符,查找其对应的编码表,并将编码字符串拼接起来,形成一个完整的编码字符串。

哈夫曼解码就是将编码字符串还原为原始文本的过程。

具体实现方法如下:1. 从根节点开始遍历哈夫曼树,按照编码字符串的位数依次访问左右分支。

如果遇到叶节点,就将对应的字符记录下来,并重新回到根节点继续遍历;2. 重复步骤1,直到编码字符串中的所有位数都被遍历完毕。

四、实验步骤1. 定义编码和解码的结构体以及相关变量;3. 遍历哈夫曼树,得到每个字符的哈夫曼编码,并将编码保存到映射表中;4. 将文本中的每个字符用其对应的哈夫曼编码替换掉,并将编码字符串写入到文件中;5. 使用哈夫曼编码重新构造文本,并将结果输出到文件中。

五、实验总结通过本次实验,我掌握了哈夫曼树的创建和哈夫曼编码的实现方法,也学会了如何用C++语言来组织程序结构,实现哈夫曼编码和解码。

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构实验报告――实验五简单哈夫曼编/译码的设计与实现本实验的目的是通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在实际问题中的应用。

此实验可以作为综合实验,阶段性实验时可以选择其中的几个功能来设计和实现。

一、【问题描述】利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。

但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码,此实验即设计这样的一个简单编/码系统。

系统应该具有如下的几个功能:1、接收原始数据。

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

2、编码。

利用已建好的哈夫曼树(如不在内存,则从文件nodedata.dat中读入),对文件中的正文进行编码,然后将结果存入文件code.dat中。

3、译码。

利用已建好的哈夫曼树将文件code.dat中的代码进行译码,结果存入文件textfile.dat中。

4、打印编码规则。

即字符与编码的一一对应关系。

二、【数据结构设计】1、构造哈夫曼树时使用静态链表作为哈夫曼树的存储。

在构造哈夫曼树时,设计一个结构体数组HuffNode保存哈夫曼树中各结点的信息,根据二叉树的性质可知,具有n个叶子结点的哈夫曼树共有2n-1个结点,所以数组HuffNode 的大小设置为2n-1,描述结点的数据类型为:typedef struct{int weight;//结点权值int parent;int lchild;int rchild;char inf;}HNodeType;2、求哈夫曼编码时使用一维结构数组HuffCode作为哈夫曼编码信息的存储。

求哈夫曼编码,实质上就是在已建立的哈夫曼树中,从叶子结点开始,沿结点的双亲链域回退到根结点,没回退一步,就走过了哈夫曼树的一个分支,从而得到一位哈夫曼码值,由于一个字符的哈夫曼编码是从根结点到相应叶子结点所经过的路径上各分支所组成的0、1序列,因此先得到的分支代码为所求编码的低位码,后得到的分支代码位所求编码的高位码,所以设计如下数据类型:#define MAXBIT 10typedef struct{int bit[MAXBIT];int start;}HcodeType;3、文件nodedata.dat、code.dat和textfile.dat。

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告【正文】1.实验目的本实验旨在研究哈夫曼编码的原理和实现方法,通过实验验证哈夫曼编码在数据压缩中的有效性,并分析其应用场景和优缺点。

2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法,通过根据字符出现的频率构建一颗哈夫曼树,将频率较高的字符用较短的编码表示,频率较低的字符用较长的编码表示。

哈夫曼编码的编码表是唯一的,且能够实现前缀编码,即一个编码不是另一个编码的前缀。

2.2 构建哈夫曼树构建哈夫曼树的过程如下:1) 将每个字符及其频率作为一个节点,构建一个节点集合。

2) 每次从节点集合中选择出现频率最低的两个节点,构建一个新节点,并将这两个节点从集合中删除。

3) 将新节点加入节点集合。

4) 重复以上步骤,直到节点集合中只有一个节点,这个节点就是哈夫曼树的根节点。

2.3 编码过程根据哈夫曼树,对每个字符进行编码:1) 从根节点开始,根据左子树为0,右子树为1的规则,将编码依次加入编码表。

2) 对于每个字符,根据编码表获取其编码。

3) 将编码存储起来,得到最终的编码序列。

3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列,并统计各个字符的频率。

3.2 构建哈夫曼树根据字符频率构建哈夫曼树。

3.3 构建编码表根据哈夫曼树,构建每个字符的编码表。

3.4 进行编码根据编码表,对输入的字符序列进行编码。

3.5 进行解码根据哈夫曼树,对编码后的序列进行解码。

4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值,分析压缩率。

4.2 编码效率分析测试编码过程所需时间,分析编码效率。

4.3 解码效率分析测试解码过程所需时间,分析解码效率。

4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。

5.结论通过本次实验,我们深入了解了哈夫曼编码的原理和实现方法,实践了哈夫曼编码的过程,并对其在数据压缩中的有效性进行了验证。

实验结果表明,哈夫曼编码能够实现较高的压缩率和较高的编解码效率。

数据结构哈夫曼编码实验报告-无删减范文

数据结构哈夫曼编码实验报告-无删减范文

数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告实验背景哈夫曼编码是一种常用的数据压缩方法,通过使用变长编码来表示不同符号,将出现频率较高的符号用较短的编码表示,从而达到压缩数据的目的。

通过实现哈夫曼编码算法,我们能够更好地理解和掌握数据结构中的树形结构。

实验目的1. 理解哈夫曼编码的原理及实现过程。

2. 掌握数据结构中树的基本操作。

3. 进一步熟悉编程语言的使用。

实验过程1. 构建哈夫曼树首先,我们需要根据给定的字符频率表构建哈夫曼树。

哈夫曼树是一种特殊的二叉树,其叶子节点表示字符,而非叶子节点表示字符的编码。

构建哈夫曼树的过程如下:1. 根据给定的字符频率表,将每个字符视为一个节点,并按照频率从小到大的顺序排列。

2. 将频率最小的两个节点合并为一个新节点,并将其频率设置为两个节点的频率之和。

这个新节点成为新的子树的根节点。

3. 将新节点插入到原来的节点列表中,并继续按照频率从小到大的顺序排序。

4. 重复步骤2和步骤3,直到只剩下一个节点,这个节点即为哈夫曼树的根节点。

2. 哈夫曼编码表在构建完哈夫曼树后,我们需要根据哈夫曼树每个字符的哈夫曼编码表。

哈夫曼编码表是一个字典,用于存储每个字符对应的编码。

哈夫曼编码表的过程如下:1. 从哈夫曼树的根节点出发,遍历整个树。

2. 在遍历的过程中,维护一个路径,用于记录到达每个字符节点的路径,0表示左子树,1表示右子树。

3. 当到达一个字符节点时,将路径上的编码存储到哈夫曼编码表中对应的字符键下。

3. 压缩数据有了哈夫曼编码表后,我们可以使用哈夫曼编码对数据进行压缩。

将原本以字符表示的数据,转换为使用哈夫曼编码表示的二进制数据。

压缩数据的过程如下:1. 将待压缩的数据转换为对应的哈夫曼编码,将所有的编码连接成一个字符串。

2. 将该字符串表示的二进制数据存储到文件中,同时需要保存哈夫曼编码表以便解压时使用。

实验结果通过实验,我们成功实现了哈夫曼编码的构建和使用。

数据结构+哈夫曼编码+实验报告

数据结构+哈夫曼编码+实验报告

实验报告一、实验目的掌握哈夫曼树及其应用。

二、实验内容利用哈夫曼算法,构造最优二叉树,然后对构造好的二叉树的叶子结点进行前缀编码。

三、实验步骤(1)审清题意,分析并理出解决问题的基本思路。

(2)根据基本思路,设计好程序的算法。

(3)根据算法编写源程序。

(4)在计算机上编译程序,检验程序的可运行性数据结构设计:// 赫夫曼树和赫夫曼编码的存储结构typedef struct // 结点的结构,在教科书第147页{ unsigned int weight; // 结点的权值unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; // 动态分配数组存储赫夫曼树typedef char **HuffmanCode; // 动态分配数组存储赫夫曼编码表void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int* w,int n) // 算法6.12{ // w存放n个字符的权值(均>0),构造赫夫曼树HT,并求出n个字符的赫夫曼编码HC int start;unsigned f;// 以下是从叶子到根逆向求每个字符的赫夫曼编码int m,i,s1,s2;unsigned c;HuffmanTree p;char *cd;if(n<=1) // 叶子结点数不大于nreturn;m=2*n-1; // n个叶子结点的赫夫曼树共有m个结点HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用for(p=HT+1,i=1;i<=n;++i,++p,++w) // 从1号单元开始到n号单元,给叶子结点赋值{ // p的初值指向1号单元(*p).weight=*w; // 赋权值(*p).parent=0; // 双亲域为空(是根结点)(*p).lchild=0; // 左右孩子为空(是叶子结点,即单结点树)(*p).rchild=0;}for(;i<=m;++i,++p) // i从n+1到m(*p).parent=0; // 其余结点的双亲域初值为0for(i=n+1;i<=m;++i) // 建赫夫曼树{ // 在HT[1~i-1]中选择parent为0且weight最小的两个结点,其序号分别为s1和s2 select(HT,i-1,s1,s2);HT[s1].parent=HT[s2].parent=i; // i号单元是s1和s2的双亲HT[i].lchild=s1; // i号单元的左右孩子分别是s1和s2HT[i].rchild=s2;HT[i].weight=HT[s1].weight+HT[s2].weight; // i号单元的权值是s1和s2的权值之和}HC=(HuffmanCode)malloc((n+1)*sizeof(char*));// 分配n个字符编码的头指针向量([0]不用)cd=(char*)malloc(n*sizeof(char)); // 分配求编码的工作空间cd[n-1]='\0'; // 编码结束符for(i=1;i<=n;i++){ // 逐个字符求赫夫曼编码start=n-1; // 编码结束符位置for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent) // 从叶子到根逆向求编码if(HT[f].lchild==c) // c是其双亲的左孩子cd[--start]='0'; // 由叶子向根赋值'0'else // c是其双亲的右孩子cd[--start]='1'; // 由叶子向根赋值'1'HC[i]=(char*)malloc((n-start)*sizeof(char)); // 为第i个字符编码分配空间strcpy(HC[i],&cd[start]); // 从cd复制编码(串)到HC}free(cd); // 释放工作空间}#include<string.h> // 字符串函数头文件#include<ctype.h> // 字符函数头文件#include<malloc.h> // malloc()等#include<limits.h> // INT_MAX等#include<stdio.h> // 标准输入输出头文件,包括EOF(=^Z或F6),NULL等#include<stdlib.h> // atoi(),exit()#include<io.h> // eof()#include<math.h> // 数学函数头文件,包括floor(),ceil(),abs()等#include<sys/timeb.h> // ftime()#include<stdarg.h> // 提供宏va_start,va_arg和va_end,用于存取变长参数表// 函数结果状态代码。

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告
第一章实验目的
本实验旨在掌握哈夫曼编码的原理和实现方法,并通过编写代码实现一个简单的哈夫曼编码程序。

第二章实验内容
1.理解哈夫曼编码的基本概念和原理。

2.设计并实现一个哈夫曼编码的数据结构。

3.实现哈夫曼编码的压缩和解压缩功能。

4.通过实验验证哈夫曼编码的效果和压缩比。

第三章实验步骤
1.确定实验所需的编程语言和开发环境。

2.定义并实现哈夫曼编码的数据结构。

3.实现哈夫曼编码的压缩和解压缩算法。

4.设计实验样例数据,进行测试和验证。

5.分析实验结果,计算压缩比。

第四章实验结果与分析
1.实验样例数据:________提供一段文本,统计字符出现的频率,并进行哈夫曼编码。

2.实验结果:________展示压缩后的编码结果,计算压缩比。

3.分析:________分析实验结果,讨论哈夫曼编码的效果和优劣。

第五章实验总结与感想
本次实验深入了解了哈夫曼编码的原理和实现方法,通过编写代码实现哈夫曼编码的压缩和解压缩功能。

实验结果表明,哈夫曼编码能够有效地减小数据的存储空间,提高了数据传输的效率。

第六章本文档涉及附件
本实验报告所涉及到的附件包括:________
1.实验代码文件:________.c
2.实验样例数据文件:________.txt
第七章法律名词及注释
1.哈夫曼编码:________一种用于无损数据压缩的编码方法,通过对频率高的字符赋予较短的编码,对频率低的字符赋予较长的编码,从而实现压缩数据的目的。

哈夫曼实验报告

哈夫曼实验报告

一、实验目的1. 理解哈夫曼编码的基本原理和重要性。

2. 掌握哈夫曼树的构建方法。

3. 熟悉哈夫曼编码和译码的实现过程。

4. 分析哈夫曼编码在数据压缩中的应用效果。

二、实验原理哈夫曼编码是一种基于字符频率的编码方法,它利用字符出现的频率来构造一棵最优二叉树(哈夫曼树),并根据该树生成字符的编码。

在哈夫曼树中,频率越高的字符对应的编码越短,频率越低的字符对应的编码越长。

这样,对于出现频率较高的字符,编码后的数据长度更短,从而实现数据压缩。

三、实验内容1. 构建哈夫曼树:- 统计待编码数据中每个字符出现的频率。

- 根据字符频率构建哈夫曼树,其中频率高的字符作为叶子节点,频率低的字符作为内部节点。

- 重复上述步骤,直到树中只剩下一个节点,即为哈夫曼树的根节点。

2. 生成哈夫曼编码:- 从哈夫曼树的根节点开始,对每个节点进行遍历,根据遍历方向(左子树为0,右子树为1)为字符分配编码。

- 将生成的编码存储在编码表中。

3. 编码和译码:- 使用生成的编码表对原始数据进行编码,将编码后的数据存储在文件中。

- 从文件中读取编码后的数据,根据编码表进行译码,恢复原始数据。

四、实验步骤1. 编写代码实现哈夫曼树的构建:- 定义节点结构体,包含字符、频率、左子树、右子树等属性。

- 实现构建哈夫曼树的核心算法,包括节点合并、插入等操作。

2. 实现编码和译码功能:- 根据哈夫曼树生成编码表。

- 编写编码函数,根据编码表对数据进行编码。

- 编写译码函数,根据编码表对数据进行译码。

3. 测试实验效果:- 选择一段文本数据,使用实验代码进行编码和译码。

- 比较编码前后数据的长度,分析哈夫曼编码的压缩效果。

五、实验结果与分析1. 哈夫曼树构建:- 成功构建了哈夫曼树,树中节点按照字符频率从高到低排列。

2. 哈夫曼编码:- 成功生成编码表,字符与编码的对应关系符合哈夫曼编码原理。

3. 编码与译码:- 成功实现编码和译码功能,编码后的数据长度明显缩短,译码结果与原始数据完全一致。

数据结构实验报告(哈夫曼树)

数据结构实验报告(哈夫曼树)

数据结构实验报告实验题目:Huffman编码与解码姓名:学号:院系:实验名称:Huffman编码与解码实验问题描述:本实验需要以菜单形式完成以下功能:1.输入电文串2.统计电文串中各个字符及其出现的次数3.构造哈弗曼树4.进行哈弗曼编码5.将电文翻译成比特流并打印出来6.将比特流还原成电文数据结构的描述:逻辑结构:本实验可用二叉树实现,其逻辑结构为一对二的形式,即一个结点对应两个结点。

在实验过程中我们也应用到了栈的概念。

存储结构:使用结构体来对数据进行存储:typedef struct{int weight;int parent,lc,rc;}HTNode,*HuffmanTree;typedef struct LNode{char *elem;int stacksize;int top;}SqStack;在main函数里面定义一个哈弗曼树并实现上述各种功能。

程序结构的描述:本次实验一共构造了10个函数:1.void HuffTree(HuffmanTree &HT,int n[],int mun);此函数根据给定的mun个权值构建哈弗曼树,n[]用于存放num个权值。

2.void Select(HuffmanTree &HT,int n,int i,int &s1,int &s2);此函数用于在HT[1,i-1]中选择parent为0且weight为最小的两个结点,其下标分别为s1,s2.3.void HuffmanCoding(HuffmanTree HT,char **&HC,int n);此函数从哈弗曼树HT上求得n 个叶子结点的哈弗曼编码并存入数组HC中。

4.void Coding(HuffmanTree HT,char **HC,int root,SqStack &S);此函数用于哈弗曼编码,先序遍历哈弗曼树HT,求得每个叶子结点的编码字符串,存入数组HC,S为一个顺序栈,用来记录遍历路径,root是哈弗曼数组HT中根结点的位置下标。

数据结构 哈夫曼编码实验报告(2023版)

数据结构 哈夫曼编码实验报告(2023版)

数据结构哈夫曼编码实验报告实验目的:本实验旨在了解和实现哈夫曼编码算法,通过将字符转换为对应的哈夫曼编码来实现数据的压缩和解压缩。

一、引言1.1 背景介绍哈夫曼编码是一种基于字符出现频率的编码方法,通过使用不等长编码来表示不同字符,从而实现数据的高效压缩。

该编码方法在通信、存储等领域有着广泛的应用。

1.2 目标本实验的目标是实现哈夫曼编码算法,通过对给定文本进行编码和解码,验证哈夫曼编码的有效性和可靠性。

二、实验过程2.1 数据结构设计在实现哈夫曼编码算法时,我们需要设计合适的数据结构来存储字符和对应的编码。

常用的数据结构包括树和哈希表。

我们将使用二叉树作为数据结构来表示字符的编码。

2.2 构建哈夫曼树哈夫曼树是由给定字符集合构建而成的最优二叉树。

构建哈夫曼树的过程分为两步:首先根据字符出现频率构建叶子节点,然后通过合并叶子节点和父节点构造哈夫曼树。

2.3 哈夫曼编码表根据构建好的哈夫曼树,我们可以对应的哈夫曼编码表。

哈夫曼编码表由字符和对应的编码组成,可以用于字符的编码和解码。

2.4 文本压缩利用的哈夫曼编码表,我们可以对给定的文本进行压缩。

将文本中的字符逐个替换为对应的哈夫曼编码,从而实现数据的压缩。

2.5 文本解压缩对压缩后的数据进行解压缩时,我们需要利用的哈夫曼编码表,将哈夫曼编码逐个替换为对应的字符,从而还原出原始的文本数据。

三、实验结果我们使用不同长度、不同频率的文本进行了实验。

实验结果表明,哈夫曼编码在数据压缩方面有着显著的效果,可以大大减小数据存储和传输的开销。

四、实验总结通过本实验,我们深入理解了哈夫曼编码算法的原理和实现过程,掌握了数据的压缩和解压缩技术。

哈夫曼编码作为一种经典的数据压缩算法,具有重要的理论意义和实际应用价值。

附件:本文档附带哈夫曼编码实验的源代码和实验数据。

法律名词及注释:在本文档中,涉及的法律名词和注释如下:1.哈夫曼编码:一种数据压缩算法,用于将字符转换为可变长度的编码。

数据结构 哈夫曼编码实验报告

数据结构 哈夫曼编码实验报告

数据结构哈夫曼编码实验报告数据结构实验报告----------1-实验目的----------本实验的目的是通过实现哈夫曼编码算法,加深对数据结构中树和堆的理解,以及掌握相关的编程技巧。

2-实验内容----------2-1 算法简介----------哈夫曼编码是一种无损压缩算法,通过根据字符出现的频率构建一颗二叉树,并将出现频率较高的字符编码为较短的二进制串,进而实现压缩的目的。

在本实验中,我们需要实现以下功能:●构建哈夫曼树●字符编码表●对给定的字符串进行编码●对给定的二进制串进行解码●实现压缩和解压缩功能2-2 数据结构----------在实现哈夫曼编码算法时,我们需要使用以下数据结构:●链表:用于存储字符出现的频率及对应的字符●堆:用于构建哈夫曼树●树:用于存储哈夫曼编码树●散列表或映射:用于存储字符的编码2-3 算法步骤----------1-统计字符的出现频率,并构建频率链表2-根据频率链表构建哈夫曼树3-字符的编码表4-对给定的字符串进行编码5-对给定的二进制串进行解码6-实现压缩和解压缩功能3-实验实现----------3-1 数据结构的设计----------在本实验中,我们将使用以下数据结构:●链表节点结构体:用于存储字符和频率●链表结构体:用于存储链表节点的头指针●堆节点结构体:用于存储字符和频率,并维护堆的结构●堆结构体:用于存储堆的根节点●树节点结构体:用于存储字符和编码,并维护哈夫曼树的结构●树结构体:用于存储哈夫曼树的根节点●散列表结构体:用于存储字符和对应的编码3-2 算法实现----------1-统计字符的出现频率并构建频率链表:遍历给定的字符串,统计字符的频率,并将字符频率按从小到大的顺序插入到频率链表中。

2-根据频率链表构建哈夫曼树:将频率链表的节点插入到堆中,并按照堆的定义调整堆的结构,直到堆中只有一个节点。

3-字符的编码表:遍历哈夫曼树,递归构造字符的编码表。

数据结构实验报告 哈夫曼树的实现

数据结构实验报告 哈夫曼树的实现

数据结构实验报告实验二Huffman树1、实验目的通过选择下面两个题目之一进行实现,掌握如下内容:➢掌握二叉树基本操作的实现方法➢了解哈夫曼树的思想和相关概念➢学习使用二叉树解决实际问题的能力2、实验内容利用二叉树结构实现哈夫曼编/解码器。

基本要求:1、初始化(Init):能够对输入的任意长度的字符串s进行统计,统计每个字符的频度,并建立赫夫曼树2、建立编码表(CreateTable):利用已经建好的哈夫曼树进行编码,并将每个字符的编码输出。

3、编码(Encoding):根据编码表对输入的字符串进行编码,并将编码后的字符串输出。

4、译码(Decoding):利用已经建好的哈夫曼树对编码后的字符串进行译码,并输出译码结果。

5、打印(Print):以直观的方式打印哈夫曼树(选作)6、计算输入的字符串编码前和编码后的长度,并进行分析,讨论哈夫曼编码的压缩效果。

代码要求:1、必须要有异常处理,比如删除空链表时需要抛出异常;2、保持良好的编程的风格:➢代码段与段之间要有空行和缩近➢标识符名称应该与其代表的意义一致➢函数名之前应该添加注释说明该函数的功能➢关键代码应添加注释说明其功能3、递归程序注意调用的过程,防止栈溢出4、代码中需要标注每一个函数的时间复杂度三、算法思路与主要代码1.设计存储结构1.1 哈夫曼树的结点结构struct HNode //哈夫曼树的结点结构{int weight;//结点权值int parent;//双亲指针int LChild;//左孩子指针int RChild ;//右孩子指针};1.2 编码表结点结构struct HCode //编码表结点结构{char data;char code[100];};1.3哈夫曼树类结构class Huffman //哈夫曼树类结构{private:HNode* HTree;HCode* HCodeTable;char str[1024];char leaf[256];int a[256];void code(int i,string newcode);public:int n;void init();void CreateHtree();void SelectMin(int &x, int &y, int s,int e);void CreateCodeTable();void Encode(char *d);void Decode(char *s, char *d);void print(int i,int m);~Huffman(); //析构函数};2.统计字符串中的字频扫描原始数据,用整型数组变量nNum来记录每一个字符出现的次数当字符没有出现时,对应的nNum[ch]的值为0,可以把读取的字符ch的ASCII码当成,当ch出现时,nNum[ch]自动加一从而统计输入字符串中各个字符数量,获得各个字符出现频率。

数据结构实验哈夫曼树及哈夫曼编码c语言

数据结构实验哈夫曼树及哈夫曼编码c语言

数据结构实验报告:哈夫曼树及哈夫曼编码一、实验目的1. 理解哈夫曼树及哈夫曼编码的概念和原理;2. 掌握C语言中哈夫曼树及哈夫曼编码的实现方法;3. 分析和讨论哈夫曼编码在实际应用中的优势和不足。

二、实验内容和步骤1. 哈夫曼树的构建1.1 通过C语言实现哈夫曼树的构建算法;1.2 输入一组权值,按哈夫曼树构建规则生成哈夫曼树;1.3 输出生成的哈夫曼树结构,并进行可视化展示。

2. 哈夫曼编码的实现2.1 设计哈夫曼编码的实现算法;2.2 对指定字符集进行编码,生成哈夫曼编码表;2.3 对给定字符串进行哈夫曼编码,并输出编码结果。

三、实验过程及结果1. 哈夫曼树的构建在C语言中,通过定义结构体和递归算法实现了哈夫曼树的构建。

根据输入的权值,依次选择权值最小的两个节点构建新的父节点,直至构建完成整棵哈夫曼树。

通过调试和可视化展示,确认了程序正确实现了哈夫曼树的构建。

2. 哈夫曼编码的实现经过分析和设计,利用哈夫曼树的特点实现了哈夫曼编码的算法。

根据生成的哈夫曼树,递归地生成字符对应的哈夫曼编码,并输出编码结果。

对指定的字符串进行了编码测试,验证了哈夫曼编码的正确性和有效性。

四、实验结果分析1. 哈夫曼编码在数据传输和存储中具有较高的压缩效率和可靠性,能够有效减少数据传输量和存储空间;2. 哈夫曼树及哈夫曼编码在通信领域、数据压缩和加密等方面有着广泛的应用和重要意义;3. 在实际应用中,哈夫曼编码的构建和解码算法需要较大的时间和空间复杂度,对于大规模数据的处理存在一定的局限性。

五、实验总结通过本次实验,深入理解了哈夫曼树及哈夫曼编码的理论知识,并掌握了C语言中实现哈夫曼树及哈夫曼编码的方法。

对哈夫曼编码在实际应用中的优势和局限性有了更深入的认识,这对今后的学习和工作有着积极的意义。

六、参考文献1. 《数据结构(C语言版)》,严蔚敏赵现军著,清华大学出版社,2012年;2. 《算法导论》,Thomas H. Cormen 等著,机械工业出版社,2006年。

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验目的本次实验的主要目的是深入理解和掌握哈夫曼树的数据结构及其相关算法,并通过实际编程实现来提高对数据结构的应用能力和编程技能。

二、实验环境本次实验使用的编程环境为具体编程语言名称,操作系统为具体操作系统名称。

三、实验原理哈夫曼树,又称最优二叉树,是一种带权路径长度最短的二叉树。

其基本原理是通过构建一棵二叉树,使得权值较大的节点距离根节点较近,权值较小的节点距离根节点较远,从而达到带权路径长度最小的目的。

在构建哈夫曼树的过程中,首先需要将所有的节点按照权值从小到大进行排序。

然后,选取权值最小的两个节点作为左右子树,构建一个新的父节点,该父节点的权值为左右子节点权值之和。

重复这个过程,直到所有的节点都被构建到哈夫曼树中。

哈夫曼编码是基于哈夫曼树的一种编码方式。

对于每个叶子节点,从根节点到该叶子节点的路径上,向左的分支编码为 0,向右的分支编码为 1,这样就可以得到每个叶子节点的哈夫曼编码。

四、实验步骤1、定义节点结构体```ctypedef struct HuffmanNode {char data;int weight;struct HuffmanNode left;struct HuffmanNode right;} HuffmanNode;```2、实现节点排序函数```cvoid sortNodes(HuffmanNode nodes, int n) {for (int i = 0; i < n 1; i++){for (int j = 0; j < n i 1; j++){if (nodesj>weight > nodesj + 1>weight) {HuffmanNode temp = nodesj;nodesj = nodesj + 1;nodesj + 1 = temp;}}}}```3、构建哈夫曼树```cHuffmanNode buildHuffmanTree(HuffmanNode nodes, int n) {while (n > 1) {sortNodes(nodes, n);HuffmanNode left = nodes0;HuffmanNode right = nodes1;HuffmanNode parent =(HuffmanNode )malloc(sizeof(HuffmanNode));parent>data ='\0';parent>weight = left>weight + right>weight;parent>left = left;parent>right = right;nodes0 = parent;nodes1 = nodesn 1;n;}return nodes0;}```4、生成哈夫曼编码```cvoid generateHuffmanCodes(HuffmanNode root, int codes, int index) {if (root>left) {codesindex = 0;generateHuffmanCodes(root>left, codes, index + 1);}if (root>right) {codesindex = 1;generateHuffmanCodes(root>right, codes, index + 1);}if (!root>left &&!root>right) {printf("%c: ", root>data);for (int i = 0; i < index; i++){printf("%d", codesi);}printf("\n");}}```5、主函数```cint main(){HuffmanNode nodes5 ={(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode))};nodes0>data ='A';nodes0>weight = 5;nodes1>data ='B';nodes1>weight = 9;nodes2>data ='C';nodes2>weight = 12;nodes3>data ='D';nodes3>weight = 13;nodes4>data ='E';nodes4>weight = 16;HuffmanNode root = buildHuffmanTree(nodes, 5);int codes100;generateHuffmanCodes(root, codes, 0);return 0;}```五、实验结果与分析通过运行上述程序,得到了每个字符的哈夫曼编码:A: 00B: 01C: 10D: 110E: 111分析实验结果可以发现,权值较小的字符A 和B 对应的编码较短,而权值较大的字符D 和E 对应的编码较长。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构与程序设计专题实验报告:学号:班级:信息45班:学号:班级:信息45班:学号:班级:信息45班实验指导老师:峰实验地点:西一楼一层计算机中心机房实验结束日期:12月5日联系:一.实验任务:对于给定的源文档 SourceDoc.txt,1) 统计其中所有字符的频度(某字符的频度等于其出现的总次数除以总字符数),字符包括字母(区分大小写)、标点符号及格式控制符(空格、回车等)。

2) 按频度统计结果构建哈夫曼编码表。

3) 基于哈夫曼编码表进行编码,生成对应的二进制码流,并输出到文件 Encode.dat,完成信源的编码过程。

4) 根据生成的哈夫曼编码表,对二进制码流文件 Encode.dat 进行解码,把结果输出到文件 TargetDoc.txt,完成信源的解码过程。

5) 判断 TargetDoc.txt 与 SourceDoc.txt 容是否一致,以验证编解码系统的正确性。

二.实验容:1) 线性链表的构建以及排序;2) 哈夫曼树的构建;3) 基于哈夫曼码进行编码;4) 对二进制码进行解码;5)对生成文件与原文件进行比较;三.程序的算法描述四.程序运行结果:五.源程序代码:#include<stdio.h>#include<stdlib.h>#include<math.h>#include <string.h> typedef struct aa {char data;double rate;int count;struct aa *next;struct aa *pre;char haffmancode[120]; }NODE;NODE *creat(char b[]){ NODE *h, *p, *s,*death;int i;h=(NODE*)malloc(sizeof(NODE));p=(NODE*)malloc(sizeof(NODE)); h->next=p;h->pre=NULL;p->pre=h;p->next=NULL;p->data=b[0]; p->count=1.0;for(i=1;b[i]!='\0';i++){s=(NODE*)malloc(sizeof(NODE));s->data=b[i]; s->count=1.0;s->next=NULL; s->pre=p;p->next=s;p=s;}return h;}void fun(NODE* h,int amount){ NODE *p,*q,*death;for(p=h->next;p;p=p->next){for(q=p->next;q;){if(q->data==p->data){(p->count)++;if (q->next == NULL){q->pre->next = NULL;free(q);break;}else{ q->pre->next=q->next;q->next->pre=q->pre;death=q; q=q->next;free(death);}}else q=q->next;}(p->rate)=1.0*(p->count)/amount;//printf("%c:\t%d\t%f\n",p->data,p->count,p->rate); }puts("构建链表完成\n");}void outlink(NODE* h,int *n){//printf("%d",amount);NODE* p=(NODE*)malloc(sizeof(NODE)); NODE* s=(NODE*)malloc(sizeof(NODE));int i;char ch;double r;for(p=h->next;p;p=p->next){for(s=p->next;s;s=s->next){if(s->count > p->count){i=p->count;p->count=s->count;s->count=i;ch=p->data;p->data=s->data;s->data=ch;r=p->rate;p->rate=s->rate;s->rate=r;}}}p=h->next;while(p){//printf("%c:\t%d\t%f\n",p->data,p->count,p->rate); (*n)++;p=p->next;}puts("排序完成\n");}typedef struct{NODE body;int lchild,rchild,parent;struct Treenode *next;}HTNode, *Tree;typedef char **Huffmancode;void select(Tree &HT,int n,int & s1,int &s2){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].body.rate>HT[i].body.rate)&&(!HT[i].parent)&&(s2!=i)) s1=i;for(j = 1;j <= n;j++)if((HT[s2].body.rate>HT[j].body.rate)&&(!HT[j].parent)&&(s1!=j)) s2=j;}void Huffmancoding(Tree &HT, Huffmancode &HC, int n,NODE *head,int *wei){HTNode *p;int m=2*n-1,i;int s1,s2;NODE *L=head->next;HT=(Tree)malloc((m+1)*sizeof(HTNode));for(p=HT+1,i=1;i<=n;i++,p++){p->body=*L;L=L->next;p->lchild=0; p->parent=0; p->rchild=0;}for(;i<=m;p++,i++){p->body.rate=0; p->lchild=0; p->parent=0; p->rchild=0;}for(i=n+1;i<=m;i++){select(HT,i-1,s1,s2);HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1;HT[i].rchild=s2; HT[i].body.rate=HT[s1].body.rate+HT[s2].body.rate;} for(i=n+1;i<=m;i++){if(HT[i].parent==0){*wei=i;}}HC=(Huffmancode)malloc((n+1)*sizeof(char *));char * temp=(char *)malloc(n*sizeof(char));temp[n-1]='\0';for(i=0;i<n;i++){int start=n-1;for(int f=HT[i].parent,h=i;f;h=f,f=HT[f].parent){if(HT[f].lchild==h){temp[--start]='0';}else{temp[--start]='1';}}//HC[i]=(char *)malloc((n-start)*sizeof(char));strcpy(HT[i].body.haffmancode,&temp[start]);}free(temp);FILE *fw;fw=fopen("Statistic.txt","wt");for(i=1;i<n;i++){fprintf(fw,"%c:\t%d\t%f\t%s\n",HT[i].body.data,HT[i].body.count,HT[i] .body.rate,HT[i].body.haffmancode);}puts("哈夫曼编码完成,Statistic.txt文件生成完毕\n");fclose(fw);}void putdat(NODE* h,FILE *fp,FILE *ft,FILE *fw,Tree &HT,int *wei,int *nc){char qq[10000]={0};int t[10000]={0};int i=0,j=0,n=0,last=*nc;rewind(fp);char pp[10000]={0};//strcpy(pp,"\0");NODE *L=h->next;while(L){i=0;while(i<last){if(L->data==HT[i].body.data)strcpy(L->haffmancode,HT[i].body.haffmancode);i++;}L=L->next;}char cp=fgetc(fp);while(cp!=EOF){L=h->next;while(cp!=L->data)L=L->next;strcat(pp,L->haffmancode);cp=fgetc(fp);}//printf("%s\n\n",pp);i=0;while(pp[i]!='\0'){n=0;while(n<15&&pp[i]!='\0'){if(pp[i]=='1'){t[j]=t[j]|1;}if(n!=14&&pp[i+1]!='\0'){t[j]=t[j]<<1;} n++;i++;}if(pp[i]=='\0'){t[j+1]=0;last=n;break;}j++;}//for(;t[n]!=0;n++);//itoa(t[0],string,2);printf("string=%s\n",string);fwrite(&t[0],sizeof(char),j-1,fw);i=0;j=0;while(t[j+1]!='\0'){n=14;while(n>=0){double a=pow(2,n);if((t[j]&(int)a)==(int)a){qq[i]='1';}else {qq[i]='0';}n--;i++;}j++;}n=last-1;while(n>=0){double a=pow(2,n);if((t[j]&(int)a)==(int)a)qq[i]='1';else qq[i]='0';n--;i++;}qq[i]='\0';//printf("%s",qq);int root=*wei;char c;i=0;while(qq[i]!='\0'){ c=qq[i];if(qq[i]=='0'){root=HT[root].lchild;}else{root=HT[root].rchild;}if(HT[root].rchild==0&&HT[root].lchild==0){ fprintf(ft,"%c",HT[root].body.data);root=*wei;}i++;}puts("解码完成,Target.txt文件生成\n"); }bool compare(FILE *fp,FILE *ft){rewind(fp);char ch1=fgetc(fp);char ch2=fgetc(ft);while(ch1!=EOF&&ch2!=EOF){if(ch1!=ch2)break;ch1=fgetc(fp);ch2=fgetc(ft);}return ch1==ch2&&ch1==EOF? true:false; }int main(){ FILE *fp;char ch;intt=0;char b[10000];if((fp=fopen("source.txt","rt"))==NULL) {printf("\ncan not open file");return 0;}ch=fgetc(fp);while(ch!=EOF){ch=fgetc(fp);b[cnt] = ch;t ++;}FILE *fw;fw=fopen("Encode.dat","wb");if(!fw){printf("NO SPACE %s\n");return 0;}int amount=strlen(b);int n=0,m=2*n-1,i;NODE *head;head=creat(b);fun(head,amount);outlink(head,&n);Tree HT;char **HC;float temp;int wei;HT=(Tree)malloc((m+1)*sizeof(HTNode));HC=(Huffmancode)malloc((n)*sizeof(char *)); Huffmancoding(HT,HC,n,head,&wei);FILE *ft;ft=fopen("Target.txt","wt");if(!ft){printf("NO SPACE FOR Target.txt");return 0;}putdat(head,fp,ft,fw,HT,&wei,&n);fclose(ft);fclose(fp);if(!ft){printf("NO SPACE FOR Target.txt");return 0;}fclose(ft);FILE *ftnew;ftnew=fopen("TargetDoc.txt","rt+");bool result=compare(fp,ftnew);if(result==true){puts("目标文件与原文件一致\n");}elseputs("目标文件与原文件不一致\n");fclose(ftnew);system("pause");return 0;}六.实验总结:从程序的编写来看,感觉这次自己真的学到了好多,特别是对程序的开发流程。

相关文档
最新文档