下载文档原格式
《数据结构与算法》实验报告一、需求分析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. 将该字符串表示的二进制数据存储到文件中，同时需要保存哈夫曼编码表以便解压时使用。
实验结果通过实验，我们成功实现了哈夫曼编码的构建和使用。
数据结构与程序设计专题实验报告：学号：班级：信息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;}六．实验总结：从程序的编写来看，感觉这次自己真的学到了好多，特别是对程序的开发流程。
