哈夫曼树及编码综合实验报告
哈夫曼编码的实验报告
哈夫曼编码的实验报告哈夫曼编码的实验报告一、引言信息的传输和存储是现代社会中不可或缺的一部分。
然而，随着信息量的不断增加，如何高效地表示和压缩信息成为了一个重要的问题。
在这个实验报告中，我们将探讨哈夫曼编码这一种高效的信息压缩算法。
二、哈夫曼编码的原理哈夫曼编码是一种变长编码方式，通过将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现信息的压缩。
它的核心思想是利用统计特性，将出现频率较高的字符用较短的编码表示，从而减少整体编码长度。
三、实验过程1. 统计字符频率在实验中，我们首先需要统计待压缩的文本中各个字符的出现频率。
通过遍历文本，我们可以得到每个字符出现的次数。
2. 构建哈夫曼树根据字符频率，我们可以构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，其中每个叶子节点代表一个字符，并且叶子节点的权值与字符的频率相关。
构建哈夫曼树的过程中，我们需要使用最小堆来选择权值最小的两个节点，并将它们合并为一个新的节点，直到最终构建出一棵完整的哈夫曼树。
3. 生成编码表通过遍历哈夫曼树，我们可以得到每个字符对应的编码。
在遍历过程中，我们记录下每个字符的路径，左边走为0，右边走为1，从而生成编码表。
4. 进行编码和解码在得到编码表后，我们可以将原始文本进行编码，将每个字符替换为对应的编码。
编码后的文本长度将会大大减少。
为了验证编码的正确性，我们还需要进行解码，将编码后的文本还原为原始文本。
四、实验结果我们选取了一段英文文本作为实验数据，并进行了哈夫曼编码。
经过编码后，原始文本长度从1000个字符减少到了500个字符。
解码后的文本与原始文本完全一致，验证了哈夫曼编码的正确性。
五、讨论与总结哈夫曼编码作为一种高效的信息压缩算法，具有广泛的应用前景。
通过将出现频率较高的字符用较短的编码表示，哈夫曼编码可以在一定程度上减小信息的存储和传输成本。
然而，哈夫曼编码也存在一些局限性，例如对于出现频率相近的字符，编码长度可能会相差较大。
哈夫曼树的实验报告1
哈夫曼树的实验报告1一、需求分析1、本演示程序实现Haffman编/译码器的作用，目的是为信息收发站提供一个编/译系统，从而使信息收发站利用Haffman编码进行通讯，力求达到提高信道利用率，缩短时间，降低成本等目标。
系统要实现的两个基本功能就是：①对需要传送的数据预先编码；②对从接收端接收的数据进行译码；2、本演示程序需要在终端上读入n个字符（字符型）及其权值（整形），用于建立Huffman树,存储在文件hfmanTree.txt中；如果用户觉得不够清晰还可以打印以凹入表形式显示的Huffman树；3、本演示程序根据建好的Huffman树，对文件的文本进行编码，结果存入文件CodeFile中；然后利用建好的Huffman树将文件CodeFile中的代码进行译码，结果存入文件TextFile中；最后在屏幕上显示代码（每行50个），同时显示对CodeFile中代码翻译后的结果；4、本演示程序将综合使用C++和C语言；5、测试数据：(1)教材例6-2中数据：8个字符，概率分别是0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11，可将其的权值看为5，29，7，8，14，23，3，11(2)用下表给出的字符集和频度的实际统计数据建立Haffman树，并实现以下报文的编码和一、概要设计1、设定哈夫曼树的抽象数据类型定义ADT Huffmantree{数据对象：D={a i| a i∈Charset,i=1,2,3,……n,n≥0}数据关系：R1＝{< a i-1, a i >| a i-1, a i∈D, i=2,3,……n}基本操作：Initialization(&HT，&HC,w，n,ch)操作结果：根据n个字符及其它们的权值w[i],建立Huffman树HT,用字符数组ch[i]作为中间存储变量，最后字符编码存到HC中；Encodeing(n)操作结果：根据建好的Huffman树，对文件进行编码，编码结果存入到文件CodeFile 中Decodeing(HT,n)操作结果：根据已经编译好的包含n个字符的Huffman树HT，将文件的代码进行翻译，结果存入文件T extFile中} ADT Huffmantree1）主程序模块void main(){输入信息，初始化；选择需要的操作；生成Huffman树；执行对应的模块程序；输出结果；}2）编码模块——根据建成的Huffman树对文件进行编码；3）译码模块——根据相关的Huffman树对编码进行翻译；各模块的调用关系如图所示二、详细设计1、树类型定义typedef struct {unsigned int weight; //权值char ch1; //储存输入的字符unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree;2、编码类型定义typedef char **HuffmanCode;哈夫曼编译器的基本操作设置如下Initialization(HuffmanTree &HT，HuffmanCode &HC,int *w，int &n,char *ch) //根据输入的n个字符及其它们的权值w[i],建立Huffman树HT,用字符数组ch[i]作为中间存储变量存储编码，最后转存到HC中；Encodeing(int n)//根据建好的包含n个字符的Huffman树，对文件进行编码，编码结果存入到文件CodeFile中Decodeing(HuffmanTree HT,int n)//根据已经编译好的包含n个字符的Huffman树HT，对文件的代码进行翻译，结果存入文件TextFile中基本操作操作的算法主函数及其他函数的算法void select(HuffmanTree HT,int n,int &s1,int &s2){ //依次比较，从哈夫曼树的中parent为0的节点中选择出两个权值最小的if(!HT[i].parent&&！HT[S1]&&!HT[S2]){if(HT[i].weight<ht[s1].weight){< p="">s2=s1; s1=i;}else if(HT[i].weight<ht[s2].weight&&i!=s1)< p=""> s2=i;}3、函数的调用关系图三、调试分析Encodeing Decoding Print PrintTreeInitialization1、本次实习作业最大的难点就是文件的读和写，这需要充分考虑到文件里面的格式，例如空格，换行等等，由于不熟悉C++语言和C语言的文件的输入和输出，给编程带来了很大的麻烦；2、原本计划将文本中的换行格式也进行编码，也由于设计函数比较复杂，而最终放弃；3、一开始考虑打印哈夫曼树的凹入表时是顺向思维，希望通过指针的顺序变迁来实现打印，但问题是从根结点到叶子结点的指针不是顺序存储的，所以未能成功，后来查找相关资料，最终利用递归的方法解决问题；4、程序中的数组均采用了动态分配的方法定义，力求达到减少空间的浪费；5、时间的复杂度主要是由查树这个步骤决定，因为无论是编码还是译码都需要对Huffman树进行查找和核对，但考虑到英文字母和空格也就是27个字符，影响不是很大；6、程序无论在屏幕显示还有文件存储方面都达到了不错的效果；7、程序不足的地方就是在文件文本格式方面处理得还是不够，或许可以通过模仿WORD的实现来改善。
哈夫曼树_实验报告
一、实验目的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、课题设计目的：在当今信息爆炸时代，如何采用有效的数据压缩技术节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视，哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。
哈夫曼编码是一种编码方式，以哈夫曼树—即最优二叉树，带权路径长度最小的二叉树，时常应用于数据压缩。
哈弗曼编码使用一张特殊的编码表将源字符(例如某文件中的一个符号)进行编码。
这张编码表的特殊之处在于，它是根据每一个源字符浮现的估算概率而建立起来的。
课题设计目的与设计意义2、课题设计意义：哈夫曼编码的应用很广泛，利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。
树中从根到每一个叶子都有一条路径，对路径上的各分支约定：指向左子树的分支表示“0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或者“1”的序列作为和各个叶子对应的字符的编码，这就是哈夫曼编码。
哈弗曼译码输入字符串可以把它编译成二进制代码，输入二进制代码时可以编译成字符串。
指导教师：年月日第一章需求分析 (1)第二章设计要求 (1)第三章概要设计 (2)(1)其主要流程图如图 1-1 所示。
(3)(2)设计包含的几个方面 (4)第四章详细设计 (4)(1)①哈夫曼树的存储结构描述为： (4)(2)哈弗曼编码 (5)(3)哈弗曼译码 (7)(4)主函数 (8)(5)显示部份源程序： (8)第五章调试结果 (10)第六章心得体味 (12)第七章参考文献 (12)附录： (12)在当今信息爆炸时代，如何采用有效的数据压缩技术节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视，哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。
哈夫曼编码是一种编码方式，以哈夫曼树—即最优二叉树，带权路径长度最小的二叉树，时常应用于数据压缩。
哈弗曼编码使用一张特殊的编码表将源字符 (例如某文件中的一个符号) 进行编码。
(完整word版)哈夫曼树实验报告
实验报告1、实验目的：(1）理解哈夫曼树的含义和性质。
（2）掌握哈夫曼树的存储结构以及描述方法。
(3）掌握哈夫曼树的生成方法。
（4)掌握哈夫曼编码的一般方法,并理解其在数据通讯中的应用.2、实验内容：哈夫曼树与哈弗曼编码、译码a。
问题描述：哈夫曼问题的提出可以参考教材P。
145。
利用哈弗曼编码进行通信可以大大提高通信利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码.b。
算法提示：参见教材P.147—148算法6.12、6。
13的描述.3、实验要求：建立哈夫曼树，实现编码,译码。
错误!.初始化（Initialization）。
从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。
○2。
编码（Encoding）.利用已建好的哈夫曼树(如不在内存，则从文件hfmTree中读入），对文件ToBeTran 中的正文进行编码,然后将结果存入文件CodeFile中。
○3.译码（Decoding ).利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件T extFile 中。
错误!.输出代码文件(Print）.将文件CodeFile以紧凑格式显示在终端上，每行50个代码。
同时将此字符形式的编码文件写入文件CodePrint中。
错误!。
输出哈夫曼树（TreePrinting）.将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。
测试数据：设权值c= （a，b, c, d , e, f，g，h)w=（5,29，7,8，14，23,3，11）,n=8。
按照字符‘0’或‘1’确定找左孩子或右孩子，则权值对应的编码为：5:0001,29：11，7：1110，8：111114：110，23:01,3：0000，11：001。
哈夫曼树编码实验报告
哈夫曼树编码实验报告哈夫曼树编码实验报告引言：哈夫曼树编码是一种常用的数据压缩算法，通过对数据进行编码和解码，可以有效地减小数据的存储空间。
本次实验旨在探究哈夫曼树编码的原理和应用，并通过实际案例验证其有效性。
一、哈夫曼树编码原理哈夫曼树编码是一种变长编码方式，根据字符出现的频率来确定不同字符的编码长度。
频率较高的字符编码较短，频率较低的字符编码较长，以达到最佳的数据压缩效果。
1.1 字符频率统计首先，需要对待编码的数据进行字符频率统计。
通过扫描数据，记录每个字符出现的次数，得到字符频率。
1.2 构建哈夫曼树根据字符频率构建哈夫曼树，频率较低的字符作为叶子节点，频率较高的字符作为父节点。
构建哈夫曼树的过程中，需要使用最小堆来维护节点的顺序。
1.3 生成编码表通过遍历哈夫曼树，从根节点到每个叶子节点的路径上的左右分支分别赋予0和1，生成对应的编码表。
1.4 数据编码根据生成的编码表，将待编码的数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度通常会减小，实现了数据的压缩。
1.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始数据。
二、实验过程与结果为了验证哈夫曼树编码的有效性，我们选择了一段文本作为实验数据，并进行了以下步骤：2.1 字符频率统计通过扫描文本，统计每个字符出现的频率。
我们得到了一个字符频率表，其中包含了文本中出现的字符及其对应的频率。
2.2 构建哈夫曼树根据字符频率表，我们使用最小堆构建了哈夫曼树。
频率较低的字符作为叶子节点，频率较高的字符作为父节点。
最终得到了一棵哈夫曼树。
2.3 生成编码表通过遍历哈夫曼树，我们生成了对应的编码表。
编码表中包含了每个字符的编码，用0和1表示。
2.4 数据编码将待编码的文本数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度明显减小，实现了数据的压缩。
2.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始文本数据。
哈夫曼树编码实训报告
一、实训目的本次实训旨在通过实际操作，让学生掌握哈夫曼树的基本概念、构建方法以及编码解码过程，加深对数据结构中树型结构在实际应用中的理解。
通过本次实训，学生能够：1. 理解哈夫曼树的基本概念和构建原理；2. 掌握哈夫曼树的编码和解码方法；3. 熟悉Java编程语言在哈夫曼树编码中的应用；4. 提高数据压缩和传输效率的认识。
二、实训内容1. 哈夫曼树的构建（1）创建叶子节点：根据给定的字符及其权值，创建叶子节点，并设置节点信息。
（2）构建哈夫曼树：通过合并权值最小的两个节点，不断构建新的节点，直到所有节点合并为一棵树。
2. 哈夫曼编码（1）遍历哈夫曼树：从根节点开始，按照左子树为0、右子树为1的规则，记录每个叶子节点的路径。
（2）生成编码：将遍历过程中记录的路径转换为二进制编码，即为哈夫曼编码。
3. 哈夫曼解码（1）读取编码：将编码字符串按照二进制位读取。
（2）遍历哈夫曼树：从根节点开始，根据读取的二进制位，在哈夫曼树中寻找对应的节点。
（3）输出解码结果：当找到叶子节点时，输出对应的字符，并继续读取编码字符串。
三、实训过程1. 准备工作（1）创建一个Java项目，命名为“HuffmanCoding”。
（2）在项目中创建以下三个类：- HuffmanNode：用于存储哈夫曼树的节点信息；- HuffmanTree：用于构建哈夫曼树、生成编码和解码；- Main：用于实现主函数，接收用户输入并调用HuffmanTree类进行编码和解码。
2. 编写代码（1）HuffmanNode类：```javapublic class HuffmanNode {private char data;private int weight;private HuffmanNode left;private HuffmanNode right;public HuffmanNode(char data, int weight) {this.data = data;this.weight = weight;}}```（2）HuffmanTree类：```javaimport java.util.PriorityQueue;public class HuffmanTree {private HuffmanNode root;public HuffmanNode buildHuffmanTree(char[] data, int[] weight) {// 创建优先队列，用于存储叶子节点PriorityQueue<HuffmanNode> queue = new PriorityQueue<>();for (int i = 0; i < data.length; i++) {HuffmanNode node = new HuffmanNode(data[i], weight[i]);queue.offer(node);}// 构建哈夫曼树while (queue.size() > 1) {HuffmanNode left = queue.poll();HuffmanNode right = queue.poll();HuffmanNode parent = new HuffmanNode('\0', left.weight + right.weight);parent.left = left;parent.right = right;queue.offer(parent);}root = queue.poll();return root;}public String generateCode(HuffmanNode node, String code) {if (node == null) {return "";}if (node.left == null && node.right == null) {return code;}generateCode(node.left, code + "0");generateCode(node.right, code + "1");return code;}public String decode(String code) {StringBuilder result = new StringBuilder();HuffmanNode node = root;for (int i = 0; i < code.length(); i++) {if (code.charAt(i) == '0') {node = node.left;} else {node = node.right;}if (node.left == null && node.right == null) { result.append(node.data);node = root;}}return result.toString();}}```（3）Main类：```javaimport java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();System.out.println("请输入字符及其权值（例如：a 2 b 3 c 5）："); String[] dataWeight = scanner.nextLine().split(" ");char[] data = new char[dataWeight.length / 2];int[] weight = new int[dataWeight.length / 2];for (int i = 0; i < dataWeight.length; i += 2) {data[i / 2] = dataWeight[i].charAt(0);weight[i / 2] = Integer.parseInt(dataWeight[i + 1]);}HuffmanTree huffmanTree = new HuffmanTree();HuffmanNode root = huffmanTree.buildHuffmanTree(data, weight); String code = huffmanTree.generateCode(root, "");System.out.println("编码结果：" + code);String decoded = huffmanTree.decode(code);System.out.println("解码结果：" + decoded);scanner.close();}}```3. 运行程序（1）编译并运行Main类，输入字符串和字符及其权值。
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告【正文】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.统计字符出现的频率，并按照频率从小到大排序；2.将频率最低的两个字符合并为一个节点，节点的频率为两个字符的频率之和；3.将新节点插入频率表，并将频率表重新排序；4.重复步骤2和3，直到频率表中只剩下一个节点，该节点即为哈夫曼树的根节点。
三、实验步骤1.统计输入的字符序列中每个字符出现的频率；2.根据频率构建哈夫曼树；3.根据哈夫曼树生成字符的编码表；4.将输入的字符序列编码为哈夫曼编码；5.根据哈夫曼树和编码表，解码得到原始字符序列。
四、实验结果以字符序列"abacabad"为例进行实验：1.统计字符频率的结果为：a-4次，b-2次，c-1次，d-1次；```a-4/\b-2c-1/\d-1空节点```3.根据哈夫曼树生成的编码表为：a-0，b-10，c-110，d-111；5. 根据哈夫曼树和编码表进行解码得到原始字符序列："abacabad"。
五、实验总结通过本次实验，我深入了解了哈夫曼树的原理和实现方法，掌握了使用哈夫曼树进行字符编码和解码的过程。
哈夫曼树在数据压缩中的应用非常广泛，能够有效地减小数据的存储空间，提高数据传输效率。
在实际应用中，我们可以根据不同字符出现的频率构建不同的哈夫曼树，从而实现更高效的数据压缩和解压缩算法。
哈夫曼树编码课程设计实验报告
四、综合设计（课程设计）摘要：在这次课程设计中，所进行的实验是：哈夫曼编码和编译器。
对哈夫曼树进行建立，由节点的权值建立最小二叉树，哈夫曼树haftree，并由所建立的哈夫曼树进行编码，求出各个节点的编码。
在由所求的哈夫曼树，输入一段二进制电文，能够输出那所建立的哈夫曼树中的节点。
建立的haftree用图形化表示出来。
在整个代码实现中，窗体的实现，功能的完善，哈夫曼树的建立，哈夫曼树的编码，遇到了许多难题，haftree对象数组的分配空间，节点的属性等都比较困难。
在整个过程中，用的是C#语言，包的应用，字符串数组的空间分配，在计算每个字符的权值时，用的是sizeOf()检索整个字符串，计算字符的权值，建立字符出现频度的表格，根据表格中每个字符频度建立起哈夫曼树。
从根节点出发检索每个节点的左右孩子，如果是左孩子遍历左边，路径为0，然后左孩子为根节点；如果是右孩子，遍历右孩子，路径为1，然后右孩子为根节点。
在重新上述方法，直到所有的节点都遍历完，每个节点的编码就确定后输出来。
在译码过程中，由所输入的二进制电文，根据所建立的哈夫曼树，如果是0走左边，如果是1，走右边，直到节点的左右孩子为空时，输出给节点的信息，在回到根节点重新遍历后面的二进制电文，直到所有电文都遍历完为止，输出所有从电文中译码出来的信息。
关键词：编译器；频度；译码五、综合设计（课程设计）Abstract：In this design, the experiment was : Huffman coding and compiler. The Huffman tree to establish, by the node weights to establish a minimum of two fork tree, Huffman tree haftree, and by the Huffman tree coding, and every node coding. By the Huffman tree, enter a binary message, can output the set up by the Huffman tree nodes. Establishment of haftree graphical representation. In the implementation of the code, the realization form, function perfect, Huffman tree is established, Huffman coding tree, encountered a lot of problems, an array of haftree objects allocated space, node attributes are difficult. Throughout the process, using the C# language, the application package, an array of strings in the spatial distribution, calculated for each weight of characters, using sizeOf to retrieve the entire string, calculating the weight of characters, establish character appearance frequency of form, form the basis of each character frequency established Huffman tree. Starting from the root node to retrieve each node around children, if children left traverse left, path 0, then left the child as the root node; if it is right child, traversing the right path for children, 1 children for the root node, then the right. In the new method described above, until all of the node traversal finished, each node is determined after the output coding.In the decoding process, by the input binary message, according to the established Huffman tree, if it is 0 the left, if it is 1, go right, until the left and right child node is empty, the output to the node information, in the back of the root node to traverse behind a binary message, until all message traversal finished so far, the output from all the message decoding of information.Keywords:compiler;frequency;decoding目录摘要 ................................................................................. 错误！未定义书签。
哈夫曼实验报告
一、实验目的1. 理解哈夫曼编码的基本原理和重要性。
2. 掌握哈夫曼树的构建方法。
3. 熟悉哈夫曼编码和译码的实现过程。
4. 分析哈夫曼编码在数据压缩中的应用效果。
二、实验原理哈夫曼编码是一种基于字符频率的编码方法，它利用字符出现的频率来构造一棵最优二叉树（哈夫曼树），并根据该树生成字符的编码。
在哈夫曼树中，频率越高的字符对应的编码越短，频率越低的字符对应的编码越长。
这样，对于出现频率较高的字符，编码后的数据长度更短，从而实现数据压缩。
三、实验内容1. 构建哈夫曼树：- 统计待编码数据中每个字符出现的频率。
- 根据字符频率构建哈夫曼树，其中频率高的字符作为叶子节点，频率低的字符作为内部节点。
- 重复上述步骤，直到树中只剩下一个节点，即为哈夫曼树的根节点。
2. 生成哈夫曼编码：- 从哈夫曼树的根节点开始，对每个节点进行遍历，根据遍历方向（左子树为0，右子树为1）为字符分配编码。
- 将生成的编码存储在编码表中。
3. 编码和译码：- 使用生成的编码表对原始数据进行编码，将编码后的数据存储在文件中。
- 从文件中读取编码后的数据，根据编码表进行译码，恢复原始数据。
四、实验步骤1. 编写代码实现哈夫曼树的构建：- 定义节点结构体，包含字符、频率、左子树、右子树等属性。
- 实现构建哈夫曼树的核心算法，包括节点合并、插入等操作。
2. 实现编码和译码功能：- 根据哈夫曼树生成编码表。
- 编写编码函数，根据编码表对数据进行编码。
- 编写译码函数，根据编码表对数据进行译码。
3. 测试实验效果：- 选择一段文本数据，使用实验代码进行编码和译码。
- 比较编码前后数据的长度，分析哈夫曼编码的压缩效果。
五、实验结果与分析1. 哈夫曼树构建：- 成功构建了哈夫曼树，树中节点按照字符频率从高到低排列。
2. 哈夫曼编码：- 成功生成编码表，字符与编码的对应关系符合哈夫曼编码原理。
3. 编码与译码：- 成功实现编码和译码功能，编码后的数据长度明显缩短，译码结果与原始数据完全一致。
哈弗曼树实验报告(3篇)
一、实验目的1. 理解并掌握哈弗曼树的构建原理。
2. 学会使用哈弗曼树进行数据编码和解码。
3. 了解哈弗曼编码在数据压缩中的应用。
二、实验原理哈弗曼树（Huffman Tree）是一种带权路径长度最短的二叉树，用于数据压缩。
其基本原理是：将待编码的字符集合按照出现频率从高到低排序，构造一棵二叉树，使得叶子节点代表字符，内部节点代表编码，权值代表字符出现的频率。
通过这棵树，可以生成每个字符的编码，使得编码的平均长度最小。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019四、实验步骤1. 构建哈弗曼树（1）创建一个结构体`HuffmanNode`，包含字符、权值、左子树和右子树指针。
```cppstruct HuffmanNode {char data;int weight;HuffmanNode left;HuffmanNode right;};（2）定义一个函数`HuffmanTree()`，用于创建哈弗曼树。
```cppHuffmanNode HuffmanTree(std::vector<char>& chars, std::vector<int>& weights) {// 创建初始二叉树std::vector<HuffmanNode> trees;for (int i = 0; i < chars.size(); ++i) {trees.push_back(new HuffmanNode{chars[i], weights[i], nullptr, nullptr});}// 构建哈弗曼树while (trees.size() > 1) {// 选择两个权值最小的节点auto it1 = std::min_element(trees.begin(), trees.end(),[](HuffmanNode a, HuffmanNode b) {return a->weight < b->weight;});auto it2 = std::next(it1);HuffmanNode parent = new HuffmanNode{0, it1->weight + it2->weight, it1, it2};// 删除两个子节点trees.erase(it1);trees.erase(it2);// 将父节点添加到二叉树集合中trees.push_back(parent);}// 返回哈弗曼树根节点return trees[0];}```2. 生成哈弗曼编码（1）定义一个函数`GenerateCodes()`，用于生成哈弗曼编码。
数据结构 哈夫曼编码实验报告(2023版)
数据结构哈夫曼编码实验报告实验目的：本实验旨在了解和实现哈夫曼编码算法，通过将字符转换为对应的哈夫曼编码来实现数据的压缩和解压缩。
一、引言1.1 背景介绍哈夫曼编码是一种基于字符出现频率的编码方法，通过使用不等长编码来表示不同字符，从而实现数据的高效压缩。
该编码方法在通信、存储等领域有着广泛的应用。
1.2 目标本实验的目标是实现哈夫曼编码算法，通过对给定文本进行编码和解码，验证哈夫曼编码的有效性和可靠性。
二、实验过程2.1 数据结构设计在实现哈夫曼编码算法时，我们需要设计合适的数据结构来存储字符和对应的编码。
常用的数据结构包括树和哈希表。
我们将使用二叉树作为数据结构来表示字符的编码。
2.2 构建哈夫曼树哈夫曼树是由给定字符集合构建而成的最优二叉树。
构建哈夫曼树的过程分为两步：首先根据字符出现频率构建叶子节点，然后通过合并叶子节点和父节点构造哈夫曼树。
2.3 哈夫曼编码表根据构建好的哈夫曼树，我们可以对应的哈夫曼编码表。
哈夫曼编码表由字符和对应的编码组成，可以用于字符的编码和解码。
2.4 文本压缩利用的哈夫曼编码表，我们可以对给定的文本进行压缩。
将文本中的字符逐个替换为对应的哈夫曼编码，从而实现数据的压缩。
2.5 文本解压缩对压缩后的数据进行解压缩时，我们需要利用的哈夫曼编码表，将哈夫曼编码逐个替换为对应的字符，从而还原出原始的文本数据。
三、实验结果我们使用不同长度、不同频率的文本进行了实验。
实验结果表明，哈夫曼编码在数据压缩方面有着显著的效果，可以大大减小数据存储和传输的开销。
四、实验总结通过本实验，我们深入理解了哈夫曼编码算法的原理和实现过程，掌握了数据的压缩和解压缩技术。
哈夫曼编码作为一种经典的数据压缩算法，具有重要的理论意义和实际应用价值。
附件：本文档附带哈夫曼编码实验的源代码和实验数据。
法律名词及注释：在本文档中，涉及的法律名词和注释如下：1.哈夫曼编码：一种数据压缩算法，用于将字符转换为可变长度的编码。
哈夫曼编码实验报告
实验1哈夫曼编码实验目的掌握哈夫曼编码原理，掌握哈夫曼树的生成方法。
了解数据压缩。
实验要求实现哈夫曼编解码生成算法。
3、实验内容首先统计要压缩的文件中出现的字符和字母的数量，根据字符字母和空格的概率进行编码，然后读取要编码的文件并存储到另一个文件中；然后调出编码的文件，解码输出，最后存储到另一个文件中。
5、实验原理1，哈夫曼树的定义：假设有n个权值，试着构造一个有n个叶子节点的二叉树，每个有权的叶子都是wi，其中权值路径最小的二叉树成为Huffman树或最优二叉树；2、Huffman树的构造：权值为输入频率数组，并且这些值在node对象中按data属性依次分配给HT，即每个HT节点对应一个输入频率。
然后，根据数据属性，从最小值到最大值取两个最小值和这个小的HT节点，将它们的数据相加，构造一个新的htnode作为它们的父节点。
指针parentleftchild，rightchild被分配了相应的值。
将这个新节点插入最小堆。
按照这个步骤，我们可以建造一棵树吗？通过构造的树，从下至上，从频率节点开始搜索父节点，直到父节点是树的顶点。
这样，每次向上搜索后，根据原始节点是父节点的左子节点还是右子节点来记录1或0。
这样，每个频率都有一个唯一对应的01码，任何没有前端的码都和其他完整码一样。
初始化，以文本文件中的字符数为权值，生成Huffman树，按符号概率由大到小对符号进行排序，概率最小的两个符号形成一个节点。
重复步骤（）（），直到概率和为1，从根节点到每个符号对应的“叶”，概率高的符号标为“0”，概率低的符号从根节点开始，对符号7进行编码。
实验程序ා include<iostream>ා include<iomanip>ා include<iomanip>使用命名空间STD；typedef struct//节点结构{char data；//记录字符值long int weight；//记录字符权重unsigned int parent，lchild，rchild；}Htnode，*HuffmanTree；typedef char**huffmancode；//dynamicly allocate array to store Huffman code table void select（HuffmanTree&HT，int i，int&S1，int&S2）//选择HT[1中权重最小且父节点不为0的两个节点。
哈夫曼树和哈夫曼编码——实验报告
实验报告学生姓名 学号专业 年级、班级课程名称 实验项目 排队系统的模拟 实验类型✓ 综合实验时间 年 月 日实验指导老师 实验评分1、实验项目名称哈夫曼树和哈夫曼编码2、实验目的及要求掌握哈夫曼树和哈夫曼编码的实现3、实验内容及步骤（1）新建一个工程——Win32 Console Application,为工程取名——创建一个简单的程序【S】（2）进入类视图，添加类——鼠标右键，点击New Class——输入类的名称,点击确定。
（3）将对应代码放入对应文件——5-13代码放入 hfTree.h文件；5-14、5.15代码放入hfTree.cpp文件；5-16代码放入幂函数文件ex 007.cpp。
（//后绿色的字是在分析代码）（4）组建、编译，运行结果4、实验结果及分析5-13 哈夫曼树类的定义代码分析template <class Type>//模板类class hfTree{private:struct Node//数组中的元素类型：一个结点{ Type data;//结点值int weight;//结点的权值int parent,left,right;//父结点以及左右儿子的下标地址};Node *elem;//定义一个数组,elem是数组的起始位置，哈夫曼树被保存在一个数组中int length;//数组的规模长度public:struct hfCode{//保存赫夫曼编码的类型Type data;//待编码的字符string code;//对应的哈夫曼编码};hfTree(const Type*x,const int*w,int size);//构造函数，构造函数接收一组待编码的字符以及对应的权值，构造一棵哈夫曼树void getCode(hfCode result[]);//返回哈夫曼编码的函数~hfTree(){delete []elem;}//析构函数，释放存储空间};5-14 哈夫曼树的构造函数代码分析template <class Type>hfTree<Type>::hfTree(const Type*v,const int *w,int size)//哈夫曼树的构造函数，有3个参数，一组待编码的符号，符号对应的权值，前面两个数组的数组规模{ const int MAX_INT=32767;int min1,min2;//最小树、次小树的权值int x,y;//最小树、次小树的下标length=2*size;//保存哈夫曼树的数组规模是符号数组、权值数组的两倍elem=new Node[length];//申请一个保存哈夫曼树的数组for(int i=size;i<length;++i)//for循环为数组赋初值{ elem[i].weight=w[i-size];//将待编码的符号对应的权值放到数组的后半部分elem[i].data=v[i-size];//将待编码的符号放到数组的后半部分 elem[i].parent=elem[i].left=elem[i].right=0;//将符号的父结点以及左右儿子都设为0，表明它们都是只有根结点的树}for(i=size-1;i>0;--i)//for循环完成size-1次的归并{ min1=min2=MAX_INT;x=y=0;// min1,min2分别保存两棵权值最小的数的权值，x、y分别表示这两棵树的树根在数组中的下标for(int j=i+1;j<length;++j)//找出父结点为0，且权值最小和次小的两棵树，等待归并的两棵树if(elem[j].parent==0)if(elem[j].weight<min1){min2=min1;min1=elem[j].weight;x=y;y=j;}else if(elem[j].weight<min2){min2=elem[j].weight;x=j;}elem[i].weight=min1+min2;//归并这两棵树，形成新树i，i这棵树的权值=min1+min2（分别保存挑选出的两棵权值最小的树的权值） elem[i].left=x;elem[i].right=y;elem[i].parent=0;//将挑选出来的两个结点作为左、右子树，构建一棵新树，i为根结点elem[x].parent=i;elem[y].parent=i;//i是挑选出来的两个结点的父结点}}5-15 哈夫曼的getCode函数代码分析template <class Type>void hfTree<Type>::getCode(hfCode result[])//哈夫曼树的getCode函数，返回的是一个数组，数组元素类型是hfCode，每一个元素包含待编码的符号和它对应的编码，编码是一个比特串，用字符串类型表示{ int size=length/2;//符号数组规模=哈夫曼数组规模/2int p,s;//s是追溯过程中正在处理结点的下标，p是s的父结点下标for(int i=size;i<length;++i)//读取每一个符号{result[i-size].data=elem[i].data; // result数组中第一个元素符号是哈夫曼数组elem中间的元素符号，因为哈夫曼数组elem包含了元素符号数组和元素符号权值数组，而符号数组规模=权值数组规模，所以哈夫曼数组elem数组是它们的两倍。
数据结构实验哈夫曼树及哈夫曼编码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年。
哈夫曼树实验报告
一、实验目的1. 理解哈夫曼树的基本概念和构造方法。
2. 掌握哈夫曼编码的原理和实现过程。
3. 通过实验加深对数据结构中树型结构应用的理解。
二、实验原理哈夫曼树（Huffman Tree）是一种带权重的二叉树，用于实现哈夫曼编码。
其基本思想是：将字符按照在数据集中出现的频率进行排序，然后选取两个最小频率的字符合并成一个新节点，其频率为两个字符频率之和，重复此过程，直到只剩下一个节点，即为哈夫曼树的根节点。
哈夫曼编码是一种基于哈夫曼树的编码方法，其原理是将每个字符映射到一个唯一的二进制序列，序列的长度与字符在数据集中出现的频率成反比。
频率越高，编码的长度越短，从而提高信息传输的效率。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验步骤1. 初始化（1）从数据文件中读取字符及其频率。
（2）构建一个优先队列（最小堆），将字符和频率存储在队列中。
2. 构建哈夫曼树（1）从优先队列中取出两个频率最小的节点，合并成一个新节点，其频率为两个节点频率之和。
（2）将新节点插入优先队列中。
（3）重复步骤（1）和（2），直到优先队列中只剩下一个节点，即为哈夫曼树的根节点。
3. 哈夫曼编码（1）遍历哈夫曼树，从根节点到叶子节点的路径上，左子树表示0，右子树表示1。
（2）将每个叶子节点的字符和对应的编码存储在哈夫曼编码表中。
4. 编码（1）读取待编码的文本。
（2）根据哈夫曼编码表，将文本中的每个字符映射到对应的编码。
（3）将编码序列写入文件。
5. 译码（1）读取编码文件。
（2）从哈夫曼树的根节点开始，根据编码序列的每一位，判断是左子树还是右子树。
（3）当到达叶子节点时，输出对应的字符。
（4）重复步骤（2）和（3），直到编码序列结束。
五、实验结果与分析1. 实验结果（1）成功构建了哈夫曼树，并生成了哈夫曼编码表。
（2）对给定的文本进行了编码和译码，验证了编码的正确性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《用哈夫曼编码实现文件压缩》实验报告
《用哈夫曼编码实现文件压缩》
实验报告
课程名称
数据结构 B
实验学期 2017 至 2018 学年 第 一 学期
学生所在院部 计算机学院
年级 2016 专业班级 信管 B162
学生姓名 学号
成绩评定：
1、工作量： A（ ），B（ ），C（ ），D（ ）,F( ) 2、难易度： A（ ），B（ ），C（ ），D（ ）,F( )
//将选取根结点权值最小的树作为左右子树 (*HT)[i].weight=(*HT)[s1].weight+(*HT)[s2].weight;
//置新二叉树的根结点权值为其左，右子树上根结点之和 printf("\nselect: s1=%d s2=%d\n",s1,s2);
//根结点权值最小的树在 HT 中的位置 printf(" 结点 weight parent lchild rchild "); for(j=1;j<=i;j++) //输出选取根结点权值最小的树的过程
fflush(stdin);
scanf("%d",&wei);
w[i]=wei;
}
HuffmanCoding(&HTree,&HCode,w,n);
return 1;
} 2.输出 HT 初态（每个字符的权值）
华北科技学院
《用哈夫曼编码实现文件压缩》实验报告
相应代码 void HuffmanCoding(HuffmanTree *HT,HuffmanCode *HC,int *w,int n){
for(i=1;i<=n;i++) {
(*HT)[i].weight=w[i]; (*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; }
//从叶子到根逆向求编码
else cd[--start] ='1';
(*HC)[i]=(char*)malloc((n-start)*sizeof(char)); strcpy((*HC)[i],&cd[start]);
//为第 i 个字符编码分配空间 //从 Cd 复制编码（串）到 HC
} free(cd);
//从叶子到根逆向求每个字符的哈弗曼编码 *HC=(HuffmanCode)malloc((n+1)*sizeof(char*)); cd=(char*)malloc(n*sizeof(char));
//分配 n 个编码的头指针 //分配求编码的工作空间
华北科技学院
《用哈夫曼编码实现文件压缩》实验报告
流程图如下
开始（主函数）
输入字符个数 及相应权值
输出每个字符的权值
建立哈夫曼树
输出哈夫曼树，并显示 双亲权值和左右孩子
输出哈夫曼编码 六、系统实现及测试结果：
1.输入哈夫曼字数及相应权值
华北科技学院
《用哈夫曼编码实现文件压缩》实验报告
相应代码
int main()
{
HuffmanTree HTree;
三、实验设备与环境：
微型计算机、Windows 7 操作系统 、Visual C++6.0 软件 四、实验内容：
输入的字符创建 Huffman 树，并输出各字符对应的哈夫曼编码。
五. 系统设计 输入字符的个数和各个字符以及权值，将每个字符的出现频率作为叶子结点构建 Huffman 树，规定哈夫曼树的左分支为 0，右分支为 1，则从根结点到每个叶子 结点所经过的分支对应的 0 和 1 组成的序列便为该结点对应字符的哈夫曼编码。
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) cd[--start] = '0';
printf(" 按任意键，继续....."); getch();
3.建立哈夫曼树
华北科技学院
中间一些截图此处省略
《用哈夫曼编码实现文件压缩》实验报告
相应代码 void Select(HuffmanTree *HT, int m, int *s1,int *s2) { int i,min; for(i=1;i<=m;i++) { //在(*HT) [1..i-1]中选择 parent 为 0 且 weight 最小的二个结点 if ((*HT)[i].parent==0) { min=i; i=m+1; } } for(i=1;i<=m;i++) { //parent 为 0 且 weight 最小的二个结点，第一个序号为 s1 if((*HT)[i].parent==0) { if((*HT)[i].weight<(*HT)[min].weight) min=i; } } *s1=min; for(i=1;i<=m;i++) { //在(*HT) [1..i-1]中选择 parent 为 0 且 weight 最小的二个结点 if((*HT)[i].parent==0 && i!=(*s1)) { min=i; i=m+i; } } for(i=1;i<=m;i++)
//w 存放 n 个字符的权值(均>0),构造赫夫曼树 HT,并求出 n 个字符的赫夫曼 编码 HC.
int i,j,m,s1,s2,start; char *cd; unsigned int c,f; if(n<=1) return; m=2*n-1; *HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); //0 号单元未用
//释放工作空间
for(i=1;i<=n;i++) printf("<%2d>编码:%s\n",(*HT)[i].weight,(*HC)[i]);
}//HuffmanCoding
七、实验结果分析：
编程过程遇到很多问题，一些知识掌握不够全面，好多细节考虑的也不是 很周到，尤其是遍历查找最小权值的过程，心里只有个大概思路，但总是写不对， 后来查了资料和向同学请求帮助，对这个有了更好的掌握，同时分析问题的能力 也略有提高。所以在以后的学习中，要更加认真，细心，不断地练习，努力。
} *s2=min; }//endSelect
for(i=n+1;i<=m;i++) {
Select(HT,i-1,&s1,&s2); //在 HT[1..i-1]中选择 parent 为 0 且 weight 最小的二个结点
(*HT)[s1].parent=i; (*HT)[s2].parent=i; (*HT)[i].lchild=s1; (*HT)[i].rchild=s2;
3、答辩情况：
基本操作： A（ ），B（ ），C（ ），D（ ）,F( ) 代码理解： A（ ），B（ ），C（ ），D（ ）,F( ) 4、报告规范度： A（ ），B（ ），C（ ），D（ ）,F( ) 5、学习态度： A（ ），B（ ），C（ ），D（ ）,F( )
总评成绩:_________________________________
华北科技学院
《用哈夫曼编码实现文件压缩》实验报告
{ //parent 为 0 且 weight 最小的二个结点，第二个序号为 s2 if((*HT)[i].parent==0 && i!=(*s1)) { if((*HT)[i].weight<(*HT)[min].weight) min=i; }
printf("\n%4d%8d%8d%8d%8d",j,(*HT)[j].weight,(*HT)[j].parent,(*HT)[j].lchild,(*HT)[j].r
child); printf("
按任意键，继续.....");
getch();
}
4.输出哈弗曼编码
相应代码 printf("\n%d 个字符的哈弗曼编码如下：\n",n);
指导教师:
兰芸
华北科技学院
《用哈夫曼编码实现文件压缩》实验报告
一、 实验题目：
用哈夫曼编码实现文件压缩
二、实验目的：
1、了解文件的概念。 2、掌握线性链表的插入、删除等算法。 3、掌握 Huffman 树的概念及构造方法。 4、掌握二叉树的存储结构及遍历算法。 5、利用 Huffman 树及 Huffman 编码，掌握实现文件压缩的一般原理。
HuffmanCode HCode;
int *w, i;
int n,wei;
//编码个数及权值
printf("请输入需要哈夫曼编码的字符个数:");
scanf("%d",&n);
w=(int*)malloc((n+1)*sizeof(int));
for(i=1; i<=n;i++)