2021年哈夫曼树实验报告 (1)之令狐采学创编

实验陈说之南宫帮珍创作创作时间：二零二一年六月三十日实验名称 Huffman 编码专业班级 计科三班 姓名 学号一、实验目的熟练掌握二叉树应用（Huffman 编码）的基本算法实现.二、实验内容● 1．对输入的一串电文字符实现Huffman 编码, 再对Huffman 编码生成的代码串进行译码, 输出电文字符串.实现功能如下：♦ Huffman 树的建立♦ Huffman 编码的生成编码文件的译码三、实验要求设计思路：数据结构：#define n 100 //叶子结点数#define m 2*n1 //Huffman 树中结点总数typedef struct {int weight; //权值int lchild , rchild , parent; //左右孩子及双亲指针}HTNode; //树中结点类型typedef HTNode HuffmanTree[m+1]; //0号单位不用主要实现函数：⏹ 统计字符串中字符的种类以及各类字符的个数的函数⏹ 构造Huffman 树的函数⏹ Huffman 编码的函数⏹ 建立正文的编码文件的函数⏹ 代码文件的译码函数⏹ 主函数四、实验概要设计1)功能框图五. 使用说明 Huffman 编码法式Huffman 树的建立从叶子到根逆向求编码 Huffman 编码的生成 编码文件的译码退出2.首先选择主控菜单中的把持１, 即建表, 然后进行其它把持．六．实验截图七实验体会1、构建哈夫曼树的关键在于找最小树；在F中选择两棵根结点权值最小的树作为左右子树构造一棵新的二叉树, 且至新的二叉树的根结点的权值为其左右子树上根结点的权值之和.2、由于学习的缺乏没有实现编码文件的译码, 今后会加以改进 (╯﹏╰）3、在逆向求编码的for循环里犯了一个逻辑毛病招致求出来的3、4位编码串行, 检验考试了多钟数据输入才找到原因所在, 并加以改正, 编写法式需一步一步的去调试并找到毛病所在.附源法式：#include<stdio.h>#include<stdlib.h>#include<string.h>#include<malloc.h>typedef struct{char data; //结点字符int weight; //结点权值int parent,lchild,rchild; //父子结点}HTNode,* HuffmanTree;typedef char * *HuffmanCode;void Select(HuffmanTree HT, int m, int& s1, int& s2){int i;s1 = s2 = 1;for(i=1; i<=m; i++){if (HT[i].parent==0){s1=i;break;}}for(i=i+1; i<=m; i++)。

哈夫曼树的实验报告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、实验目的：(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. 验证赫夫曼树在数据压缩中的有效性。

三、实验过程1. 构建赫夫曼树首先，我们需要统计待压缩数据中各个字符的出现频率。

然后，按照频率从小到大的顺序，将字符构建成一棵二叉树。

具体构建方法为：每次选取频率最低的两个字符，将它们作为左右子节点，生成一个新的节点，该节点的频率为左右子节点频率之和。

重复此过程，直到所有字符都被构建成树的节点。

2. 进行赫夫曼编码在赫夫曼树构建完成后，我们需要对每个字符进行编码。

编码的规则是：向左走为0，向右走为1。

从根节点开始，对每个字符进行路径搜索，直到找到对应的叶子节点，记录下路径上的0和1，即为该字符的编码。

3. 数据压缩与解压缩利用赫夫曼编码，我们可以对待压缩数据进行压缩。

将每个字符替换为对应的编码后，将所有编码拼接起来，即可得到压缩后的数据。

解压缩则是将编码根据赫夫曼树进行反向解码，得到原始数据。

四、实验结果通过实验，我们将不同类型的数据进行了压缩和解压缩，并与原始数据进行了对比。

结果表明，赫夫曼树在数据压缩中表现出色，能够显著减小数据的大小，同时保持数据的完整性。

五、实验总结赫夫曼树作为一种高效的数据压缩算法，具有广泛的应用前景。

通过本次实验，我们深入了解了赫夫曼树的原理和构建方法，并验证了其在数据压缩中的有效性。

赫夫曼树的应用不仅可以提高数据传输的效率，还可以节省存储空间，对于大数据时代的到来具有重要意义。

一、实训目的本次实训旨在通过实际操作，让学生掌握哈夫曼树的基本概念、构建方法以及编码解码过程，加深对数据结构中树型结构在实际应用中的理解。

通过本次实训，学生能够：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.掌握使用哈夫曼树进行编码和解码的方法；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哈夫曼编码实验的目的是掌握哈夫曼编码的原理，掌握哈夫曼树的生成方法。

了解数据压缩。

实验要求实现Huffman编解码器生成算法。

三。

实验内容首先统计待压缩文件中出现的字符和字母的数量，根据字符字母和空格的概率对其进行编码，然后读取要编码的文件并将其存储在另一个文件中；然后调用已编码的文件，对输出进行解码，最后存储到另一个文件中。

5实验原理1。

假设树的权值是用huffn树的定义来构造的。

每个加权叶为wi，权值路径最小的二叉树成为Huffman树或最优二叉树。

Huffman树的结构：权重是一个输入频率的数组，这些值根据节点对象中的数据属性按顺序分配给HTs，即每个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&amp;HT，int i，int&amp;S1，int&amp;S2）//选择HT[1中权重最小且父节点不为0的两个节点。

哈夫曼编码实验报告心得简介哈夫曼编码是一种用于数据压缩的算法，在信息论和编码理论中扮演着重要的角色。

它基于将出现频率较高的字符用较短的二进制编码表示，而将较少出现的字符用较长的二进制编码表示，从而达到压缩数据的目的。

在这次实验中，我对哈夫曼编码进行了深入的学习和实践，并对其进行了评估和测试。

通过实验，我对哈夫曼编码有了更深入的了解，并收获了一些宝贵的心得体会。

实验过程步骤一：构建哈夫曼树首先，我需要根据给定的数据集构建哈夫曼树。

在构建哈夫曼树的过程中，我采用了优先队列来保存节点，每次选择权重最小的节点进行合并，直到最终合并成一棵完整的哈夫曼树。

步骤二：生成编码表构建好哈夫曼树之后，我需要根据这棵树生成每个字符对应的二进制编码。

这一步需要按照哈夫曼树的路径从根节点到叶子节点进行遍历，每经过一条左子树的路径，就加上一个0，每经过一条右子树的路径，就加上一个1，直到达到叶子节点为止。

步骤三：进行编码压缩生成编码表之后，我根据编码表对原始数据进行了编码压缩。

将每个字符通过其对应的二进制编码进行替换，得到了压缩后的数据。

步骤四：进行解码还原最后，我对压缩后的数据进行解码还原。

通过对编码表的反向查找，将二进制编码转换为原始字符，得到了还原后的数据。

心得体会通过这次实验，我对哈夫曼编码有了更深入的了解。

一开始我遇到了一些困难，例如如何构建哈夫曼树和生成编码表，但通过查阅相关资料和和老师的指导，我逐渐掌握了相关的知识和技巧。

实验中，我发现哈夫曼编码在压缩数据方面有着很好的效果。

根据实验结果，使用哈夫曼编码可以将原始数据压缩到原来的约50%左右，这对于节省存储空间和加快数据传输速度都有着重要的意义。

另外，在实验过程中，我也意识到了哈夫曼编码的一些局限性。

由于是根据字符出现的频率进行编码，在处理一些重复的字符时，哈夫曼编码的压缩效果并不理想。

此外，哈夫曼编码的编解码速度受到哈夫曼树的构建和编码表的生成等步骤的影响，对于大规模数据的处理并不高效。

一、实验目的1. 理解赫夫曼树的概念和原理；2. 掌握赫夫曼树的构建方法；3. 学会使用赫夫曼树进行数据压缩和解压缩；4. 了解赫夫曼树在实际应用中的优势。

二、实验原理赫夫曼树是一种带权路径长度最短的二叉树，也称为最优二叉树。

在构建赫夫曼树的过程中，每次选择两个权值最小的节点作为左右子节点，然后合并成一个新的节点，权值为两个子节点权值之和。

重复此过程，直到只剩下一个节点，即为赫夫曼树的根节点。

赫夫曼树在数据压缩中的应用主要体现在编码和解码过程中。

通过对字符进行赫夫曼编码，可以将字符序列转换成二进制序列，从而减少数据存储空间。

在解码过程中，根据赫夫曼树的结构，可以将二进制序列还原成原始字符序列。

三、实验内容1. 构建赫夫曼树（1）输入字符及其权值，例如：A=5, B=9, C=12, D=13, E=16, F=45。

（2）将输入的字符和权值放入最小堆中，每次取出两个最小权值的节点，合并成一个新的节点，权值为两个子节点权值之和。

（3）重复步骤（2），直到只剩下一个节点，即为赫夫曼树的根节点。

2. 使用赫夫曼树进行数据压缩和解压缩（1）根据赫夫曼树生成字符的编码，例如：A=01, B=100, C=101, D=110, E=1110, F=1111。

（2）对输入的字符序列进行编码，例如：输入字符串"ABCDEF"，编码后为"01010010101111111111"。

（3）将编码后的二进制序列存储或传输。

（4）接收方根据赫夫曼树的结构，对二进制序列进行解码，还原成原始字符序列。

四、实验结果与分析1. 实验结果（1）构建赫夫曼树```F/ \B D/ \ / \A C E G```（2）字符编码```A=01, B=100, C=101, D=110, E=1110, F=1111```（3）输入字符串"ABCDEF"的编码结果为"01010010101111111111"。

哈夫曼实验报告总结哈夫曼编码是一种用于数据压缩的有效算法，它能够将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现数据的压缩。

本次实验的目的是通过实现哈夫曼编码算法，深入理解哈夫曼编码的原理和应用，并通过实验证明其压缩效果。

在实验中，我们首先需要计算每个字符在给定文本中的出现频率。

通过统计文本中的字符频率，我们可以构建出一个字符频率表，其中每个字符和其对应的频率成对出现。

接下来，根据字符频率表，我们需要构建哈夫曼树。

哈夫曼树是一种特殊的二叉树，它的叶子节点对应于字符，而非叶子节点对应于字符的编码。

构建哈夫曼树的过程是通过将频率较小的字符不断相加作为新的频率节点，直到最终构建出完整的哈夫曼树。

构建哈夫曼树的过程是一个递归的过程，可以通过优先队列或最小堆来实现。

构建完哈夫曼树后，我们可以根据哈夫曼树为每个字符生成对应的编码。

在哈夫曼树中，从根节点到叶子节点的路径表示字符的编码，路径上的左-右方向分别表示0和1。

生成编码的过程是通过遍历哈夫曼树的路径，并记录经过的方向来实现的。

为了更高效地生成编码，可以使用哈希表或者数组来存储每个字符对应的编码。

实验中，我们将生成的哈夫曼编码应用于数据的压缩。

通过将文本中的每个字符替换为其对应的哈夫曼编码，并将生成的编码串连接起来，可以实现对数据的压缩。

压缩效果取决于字符的频率分布情况，频率更高的字符会得到较短的编码，而频率较低的字符会得到较长的编码。

在本次实验中，我们通过分别计算原始文本和压缩后文本的字节数，计算了压缩率。

压缩率的计算公式为：压缩率 = (1 - 压缩后字节数 / 原始字节数) * 100%。

通过实验数据的对比，我们可以发现，哈夫曼编码能够有效地减小数据的存储空间，实现较高的压缩率。

通过本次实验，我深入学习了哈夫曼编码的原理和实现方法。

哈夫曼编码是一种非常有效的数据压缩算法，广泛应用于各类数据压缩工具和通信传输中。

哈夫曼实验报告哈夫曼实验报告一、引言信息压缩是计算机科学领域中一项重要的研究课题。

在信息传输和存储过程中，如何将数据压缩成更小的体积，既可以节省存储空间，又可以提高传输效率，一直是学术界和工业界的关注焦点。

而哈夫曼编码作为一种常用的压缩算法，具有广泛的应用前景。

本实验旨在通过实际操作，深入了解哈夫曼编码的原理和实现过程。

二、实验目的1. 了解哈夫曼编码的基本原理；2. 学习如何构建哈夫曼树；3. 实现哈夫曼编码和解码的算法；4. 分析哈夫曼编码在实际应用中的优势和局限性。

三、实验过程1. 数据收集和处理在本实验中，我们选择了一段英文文本作为实验数据。

首先，我们对文本进行了预处理，去除了标点符号和空格，并将所有字母转换为小写。

这样可以简化后续的编码和解码过程。

2. 构建哈夫曼树根据收集到的数据，我们统计了每个字符出现的频率，并按照频率从小到大的顺序构建了一个字符频率表。

接着，我们使用哈夫曼树的构建算法，将字符频率表转化为一棵哈夫曼树。

在构建过程中，我们采用了最小堆来维护频率表中的字符节点，并通过合并最小的两个节点来构建树的分支。

3. 哈夫曼编码和解码在哈夫曼树构建完成后，我们根据树的结构和字符频率表，生成了每个字符的哈夫曼编码。

编码过程中，我们采用了深度优先遍历的方法，从根节点到叶子节点依次生成编码。

同时，我们还实现了哈夫曼解码算法，通过根据编码逐步遍历哈夫曼树，将编码转换为原始字符。

四、实验结果经过实验，我们成功地实现了哈夫曼编码和解码的算法，并对实验数据进行了压缩和解压缩操作。

通过比较压缩前后数据的大小，我们发现使用哈夫曼编码后，数据的体积显著减小。

这说明哈夫曼编码在信息压缩方面具有很好的效果。

同时，我们还对不同数据集进行了实验，发现哈夫曼编码对于频率较高的字符可以实现更好的压缩效果。

这是因为哈夫曼编码可以根据字符的频率分配不同长度的编码，使得频率较高的字符使用较短的编码，从而达到更好的压缩效果。

一、实验目的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、接收原始数据。

从终端读入字符集大小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.试验内容经过二叉树结构哈夫曼树, 并用哈夫曼树对读取txt文件进行哈夫曼编码。

编码完成后经过哈夫曼树进行解码。

#include<stdio.h>#include<string.h>#define MAX 100//定义哈夫曼树存放结构typedef struct{char data;int weight;int parent;int lch;int rch;}HuffNode;//定义哈夫曼编码存放结构typedef struct{char bit[MAX];int start;}HuffCode;HuffNode ht[2*MAX];HuffCode hcd[MAX];int Coun[127]={0};int n;char s1[00];char text[5000];//结构哈夫曼树void HuffmanTree(){int i,j,k,left,right,min1,min2;//printf("输入叶子节点数: ");//scanf("%d",&n);printf("字符数量=%d\n",n);for(i=1;i<=2*n-1;i++){ht[i].parent=ht[i].lch=ht[i].rch=0;j=0;for(i=1;i<=n;i++){/*getchar();printf("输入第%d个叶子节点值: ",i);scanf("%c",&ht[i].data);printf("输入该节点权值: ");scanf("%d",&ht[i].weight);*/for(;j<127;j++){if(Coun[j]!=0){ht[i].data=j;//printf("%c",ht[i].data);ht[i].weight=Coun[j];//printf("%d",ht[i].weight);break;}}j++;}printf("\n");for(i=1;i<=n;i++)printf("%c",ht[i].data);}printf("\n");for(i=n+1;i<=2*n-1;i++){//在前n个结点中选择权值最小两个结点组成一颗二叉树min1=min2=10000;//为min1和min2设置一个比全部权值都大值left=right=0;for(k=1;k<=i-1;k++){if(ht[k].parent==0)//若是根结点//令min1和min2为最小两个权值, left和right 为权值最小两个结点位置if(ht[k].weight<min1){min2=min1;right=left;min1=ht[k].weight;left=k;}else if (ht[k].weight<min2){min2=ht[k].weight;right=k;}}ht[left].parent=i;ht[right].parent=i;ht[i].weight=ht[left].weight+ht[right].weight;ht[i].lch=left;ht[i].rch =right;}}//结构哈夫曼编码void HuffmanCode(){int i,c,k,f;HuffCode cd;for(i=1;i<=n;i++){cd.start=n;c=i;f=ht[i].parent;while(f!=0){if(ht[f].lch==c)cd.bit[cd.start]='0';elsecd.bit[cd.start]='1';cd.start--;c=f;f=ht[f].parent;}hcd[i]=cd;}printf("输出哈夫曼编码: \n");for(i=1;i<=n;i++){printf("%c:",ht[i].data);for(k=hcd[i].start+1;k<=n;k++)printf("%c",hcd[i].bit[k]);printf("\n");}}//对字母进行编码void Code()//将字符与对应哈夫曼编码进行匹配, 输出编码结果{int i=0,j,k,h=0;while(text[i]!='\0')for(j=1;j<=n;j++){if(text[i]==ht[j].data){for(k=hcd[j].start+1;k<=n;k++){s1[h]=hcd[j].bit[k];h++;}break;}}i++;}//printf("编码\n");//puts(s1);//printf("\n");}void HuffmanDecode(){printf("解码\n");int len,i,f;char C;//char S[MAXCODE];//scanf("%s",S);//使用gets()直接跳过len=strlen(s1);printf("s1:%d\n",len);f=2*n-1;for(i=0;i<len;i++){if(s1[i]=='0'){f=ht[f].lch;if(ht[f].lch==0&&ht[f].rch==0){C=ht[f].data;printf("%c",C);f=2*n-1;}}else if(s1[i]=='1'){f=ht[f].rch;if(ht[f].lch==0&&ht[f].rch==0){C=ht[f].data;printf("%c",C);f=2*n-1;}}}printf("\n");}//统计字母个数及其权值void Count(){int i,j,m;n=0;i=0;//printf("请仅输入小写字母\n");//例程本省存在一个BUG, 只输入一个字母不能进行编码（并未处理）//scanf("%s",s);while(text[i]!='\0')//使用ASCII码表进行统计{m=text[i];//printf("%d\n",m);Coun[m]++;i++;}for(j=0;j<127;j++){if(Coun[j]!=0)n++;}}//mark Codevoid main(){int l=0;FILE *fp;fp=fopen("text.txt","r");if(fp==NULL){printf("文件打开失败\n");while(1);}while(!feof(fp)){text[l] = fgetc(fp);l++;}printf("输入文本\n");printf("%s\n",text);fclose(fp);Count();HuffmanTree();HuffmanCode();Code();HuffmanDecode();}文本文件文本输入进行哈夫曼编码对文本进行编码输出解码结果3.试验总结经过此次试验, 对二叉树应用有了对应了解, 掌握了怎样结构哈夫曼编码, 怎样对编码结果进行解码。

哈夫曼树的压缩与解压1.欧阳引擎（2021.01.01）2.算法简要描述1.哈夫曼算法1.哈弗曼算法是根据给定的n个权值{w1，w2，w3.......wn}，构造由n棵二叉树构成的深林F={T1,T2,。

Tn}，其中每个二叉树Ti分别都是只含有一个权值wi的根结点，其左右子树为空（i=1，，，，，,2）。

2.在深林F中选取其根结点的权值最小的两棵二叉树，分别作其左右子树构造一颗新的二叉树，并置这棵新的二叉树根结点的权值为其左右子树的根结点之和。

3.从F中删去这两棵二叉树，同时刚新生成的二叉树加入到深林F中。

4.重复2,3,步骤，直至深林F中只含有一颗二叉树为止。

2.哈夫曼树的实现函数String EnCode(Char Type ch)：表示哈夫曼树已存在，返回字符ch的编码。

函数LinkList<CharType>UnCode(String strCode)：表示对哈夫曼树进行译码，返回编码前的字符序列。

根据算法可以看出，在具有n个结点权值的哈夫曼树的构造过程中，每次都是从F中删去两棵树，增加一棵树，即每次结束后减少一棵树，经过n1次处理后，F中就只剩下一棵树了。

另外，每次合并都要产生一个新的结点，合并n1次后共产生了n1个新结点，并且这n1个新节点都是具有左右子树的分支结点。

则最终得到的哈夫曼树中共有2n1个结点，并且其中没有度为1的分支结点，最后一次产生的新结点就是哈夫曼树的根结点。

源代码中创建了一个哈夫曼树结点类，其中有数据成员weight，parent，leftChild，rightChild分别代表了权值，双亲，左孩子，右孩子。

在哈夫曼树类中有数据成员*nodes，*LeafChars，*LeafCharCodes，curPos，num，分别用来存储结点信息，叶结点字符信息，叶结点字符编码信息，译码时从根结点到叶结点路径的当前结点，叶结点个数。

哈夫曼树类中含有多个函数，有构造函数，析构函数等。