利用哈夫曼编码实现压缩和解压缩
哈夫曼编码的应用实例
哈夫曼编码的应用实例引言哈夫曼编码是一种常用的数据压缩算法，它通过将出现频率较高的字符用较短的编码表示，从而实现对数据的高效压缩。
本文将通过几个实际应用实例来介绍哈夫曼编码的工作原理和应用场景。
什么是哈夫曼编码哈夫曼编码是由David A. Huffman于1952年提出的一种数据压缩算法。
它通过统计字符的出现频率，然后构建一棵二叉树，将频率较高的字符放在树的较低层，频率较低的字符放在树的较高层，从而实现对数据的压缩。
哈夫曼编码的原理1.统计字符的出现频率：首先需要统计待压缩数据中每个字符的出现频率。
2.构建哈夫曼树：根据字符的出现频率构建一棵哈夫曼树。
构建树的过程中，频率较低的字符被放在树的较高层，频率较高的字符被放在树的较低层。
3.生成哈夫曼编码：从根节点开始，沿着左子树走为0，沿着右子树走为1，将每个字符对应的编码记录下来。
4.进行编码压缩：将待压缩数据中的每个字符用其对应的哈夫曼编码替代。
5.进行解码还原：通过哈夫曼树和编码，将压缩后的数据解码还原为原始数据。
哈夫曼编码的应用实例文本文件压缩文本文件通常包含大量的字符，而且某些字符的出现频率较高。
通过使用哈夫曼编码，可以将出现频率较高的字符用较短的编码表示，从而实现对文本文件的高效压缩。
1.统计字符的出现频率：首先需要对待压缩的文本文件进行字符频率统计，得到每个字符的出现频率。
2.构建哈夫曼树：根据字符的出现频率构建一棵哈夫曼树。
3.生成哈夫曼编码：根据哈夫曼树，为每个字符生成对应的哈夫曼编码。
4.进行编码压缩：将待压缩的文本文件中的每个字符用其对应的哈夫曼编码替代。
5.进行解码还原：通过哈夫曼树和编码，将压缩后的数据解码还原为原始文本文件。
图像压缩图像文件通常包含大量的像素点，每个像素点包含多个颜色信息。
通过使用哈夫曼编码，可以将出现频率较高的颜色用较短的编码表示，从而实现对图像文件的高效压缩。
1.统计颜色的出现频率：首先需要对待压缩的图像文件进行颜色频率统计，得到每个颜色的出现频率。
英文文件的压缩和解压缩程序
合肥学院计算机科学与技术系一、问题分析和任务定义1、题目采用哈夫曼编码思想实现英文文本的压缩与解压缩，并提供压缩前后的占用空间比。
要求 1）压缩原文件规模不小于5K2) 提供解压缩文件后文件与原文件的相同性比较功能2、问题分析压缩过程 news.txt →news1.txt1、以读的形式打开需要压缩的一个英文本文件，把其中出现的所有字符按其在文本中出现的频率利用哈夫曼树进行编码。
2、以写的形式打开一个新的文本文件，把它作为英文文本压缩后的文本文件，扫描需要压缩的英英文本文件（ new.txt ）中所有字符，把其对应的编码通过转换后存入新的文本文件( new1.txt )中。
3、把需要压缩的英文文本（ new.txt ）中所出现的字符及其编码等原始文件的信息保存在新的文本文件中。
解压缩过程news1.txt →news2.txt1、以读的形式打开一个压缩文件 news1.txt，按其中保存的原始文件的信息还原哈夫曼树及字符编码。
2、以写的形式打开一个新的文本文件，作为解压后的英文文本 news2.txt ，逐个扫描压缩文件 news1.txt中的所有字符，把其中所有转换后的编码再转换回来并与哈夫曼树中存储的字符编码比较，把其对应的字符写入news2.txt 中。
一个字符在文本文件中存储时占一个字节，而其二进制编码若直接存入文本文件其所占的空间不会少于一个字节。
例如：假设字符E的编码为001，若把001直接存入文件只能用字符串的形式，其所占用的空间为三个字节。
达不到文件压缩的目的，所以必须对编码的存储空间进行转换。
3 编码转换在文本文件中字符之间是连续的，所以在文本文件中存储编码也是连续的。
可以把连续的不同字符的编码存入同一个字节，再把这一个字节的二进制码转换成一个字符，把转换后的字符存储在文本文件中。
二、数据结构的选择和概要设计：1 此程序采用的数据结构为顺序表。
哈夫曼树是二叉树的一种，二叉树的顺序存储结构中可以把结点间的关系放在其存储位置中，无需附加任何信息就能在这种结构中找到每个结点的双亲结点和孩子结点，这正是哈夫曼编码所需要的。
哈夫曼编解码算法设计
哈夫曼编解码算法设计1.引言1.1 概述概述部分将对哈夫曼编解码算法进行简要介绍，包括该算法的产生背景、主要特点以及应用领域等方面的内容。
哈夫曼编解码算法是一种基于权重分布的压缩算法，它通过对输入的数据流进行编码和解码来实现数据的压缩和恢复。
该算法由大卫·哈夫曼（David A. Huffman）于1952年提出，是一种被广泛应用于信息论和数据压缩领域的有效算法。
该算法的主要特点是根据输入数据的权重分布构建一棵哈夫曼树，通过不等长的编码方式来表示输入数据中出现频率较高的字符或数据块。
编码时，出现频率较高的字符使用较短的二进制编码，而出现频率较低的字符则使用较长的二进制编码，以此来实现数据的压缩效果。
哈夫曼编码算法在数据压缩领域有着广泛的应用。
由于压缩后的数据长度较短，可以大大节省存储空间和传输带宽，因此被广泛应用于各种数据传输和存储场景中，如文件压缩、图像压缩、语音压缩等。
此外，哈夫曼编码算法的设计思想也对后续的数据压缩算法提供了重要的借鉴和参考价值。
本文将详细介绍哈夫曼编码算法的原理、设计与实现，并通过实例和实验验证算法的性能和效果。
通过对哈夫曼编码算法的研究与分析，可以更好地理解该算法的优势和不足，并为后续的算法改进和优化提供参考。
最后，本文将总结哈夫曼编码算法的主要特点和应用场景，并对未来的研究方向提出展望。
1.2 文章结构文章结构部分主要介绍本文的各个部分以及每个部分的内容安排。
在本文中，共包含引言、正文和结论三个部分。
引言部分主要介绍了整篇文章的背景和目的。
在概述部分，简要说明了哈夫曼编解码算法的概念和作用，以及该算法在通信领域的重要性。
然后，文章结构部分具体说明了本文的组织结构，以便读者能够清晰地了解文章的整体脉络。
正文部分是本文的主体，分为两个部分：哈夫曼编码算法原理和哈夫曼编码算法设计与实现。
在哈夫曼编码算法原理部分，将详细介绍哈夫曼编码算法的基本原理，包括频率统计、构建哈夫曼树和生成哈夫曼编码等步骤。
用Huffman编码实现图像压缩
用Huffman编码实现图像压缩摘要：当前，网络和多媒体技术日新月异，信息量急速膨胀。
针对这种情况，本文探讨了它的解决方法——数据压缩（主要是图像压缩）。
着重研究了无失真条件下的最佳编码方法——huffman编码，对其方法的优劣做了较为客观的评价。
关键词：图像压缩编码 huffman编码中图分类号：tp393.03 文献标识码：a 文章编号：1007-9416(2011)12-0238-021、前言随着科技的发展，现在各种各样的数据和信息正在急速膨胀，每天出现的新知识正以近乎指数的规律逐日上升。
如何方便快速地存储、处理和传输这些日益增加的信息，使之更好的为我们服务，已经成为多数行业共同的呼声。
特别是近几年来随着网络走进普通家庭，昔日老牛拉破车似的网速已让多数人所不能容忍。
因为数据在数据传输时，要占据很大的信道容量。
为此，人们想到了采用对图像新的表达方法以减小表示一幅图像所需数据量，这就是图像编码要解决的主要问题。
由于图像编码减少了数据量，因此人们也常称图像编码为图像压缩。
本文将着重研究huffman编码方法，并形成一个对huffman编码方法的较为完整的评价。
2、正文2.1 huffman编码huffman编码的主导思想是根据数据符号发生的概率进行编码。
在源数据中出现概率越高的符号，相应的码长越短；出现概率越小的符号，其码长越长，从而达到用尽可能少的码符号表示源数据。
huffman编码方法是接近压缩比上限的一种最佳的编码方法。
2.2 具体编码过程(1)将信源符号按出现概率由大到小排列。
(2)将2个最小概率相加，形成一新的概率集合，对应一新的信源，符号数减小一个，即具有q-1个符号数，称为缩减信源a。
(3)将缩减信源a中q-1个符号再按概率大小排列。
如符号间概率相等，则排列次序不论。
(4)如此继续，得到具有(q-2)、(q-3)、(q-4)、...个符号的缩减信源b、c、d等，直到只有2个符号为止。
java源程序 哈夫曼编码
java源程序哈夫曼编码实现Huffman编码需要编写一些代码，因此我将提供一个简单的Java程序，演示如何使用Huffman编码对文本进行压缩和解压缩。
这个例子仅用于演示基本概念，实际使用中可能需要进行更多的优化和错误处理。
```javaimport java.util.PriorityQueue;import java.util.HashMap;import java.util.Map;class HuffmanNode implements Comparable<HuffmanNode> {char data;int frequency;HuffmanNode left, right;public HuffmanNode(char data, int frequency) {this.data = data;this.frequency = frequency;}@Overridepublic int compareTo(HuffmanNode o) {return this.frequency - o.frequency;}}public class HuffmanCoding {private static Map<Character, String> huffmanCodes = new HashMap<>();public static void main(String[] args) {String inputText = "hello world";Map<Character, Integer> frequencyMap = buildFrequencyMap(inputText);HuffmanNode root = buildHuffmanTree(frequencyMap);generateHuffmanCodes(root, "", huffmanCodes);System.out.println("Original Text: " + inputText);String encodedText = encode(inputText);System.out.println("Encoded Text: " + encodedText);String decodedText = decode(encodedText, root);System.out.println("Decoded Text: " + decodedText);}private static Map<Character, Integer> buildFrequencyMap(String text) {Map<Character, Integer> frequencyMap = new HashMap<>();for (char c : text.toCharArray()) {frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);}return frequencyMap;}private static HuffmanNode buildHuffmanTree(Map<Character, Integer> frequencyMap) { PriorityQueue<HuffmanNode> priorityQueue = new PriorityQueue<>();for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {priorityQueue.add(new HuffmanNode(entry.getKey(), entry.getValue()));}while (priorityQueue.size() > 1) {HuffmanNode left = priorityQueue.poll();HuffmanNode right = priorityQueue.poll();HuffmanNode mergedNode = new HuffmanNode('\0', left.frequency + right.frequency);mergedNode.left = left;mergedNode.right = right;priorityQueue.add(mergedNode);}return priorityQueue.poll();}private static void generateHuffmanCodes(HuffmanNode root, String code, Map<Character, String> huffmanCodes) {if (root != null) {if (root.left == null && root.right == null) {huffmanCodes.put(root.data, code);}generateHuffmanCodes(root.left, code + "0", huffmanCodes);generateHuffmanCodes(root.right, code + "1", huffmanCodes);}}private static String encode(String text) {StringBuilder encodedText = new StringBuilder();for (char c : text.toCharArray()) {encodedText.append(huffmanCodes.get(c));}return encodedText.toString();}private static String decode(String encodedText, HuffmanNode root) {StringBuilder decodedText = new StringBuilder();HuffmanNode current = root;for (char bit : encodedText.toCharArray()) {if (bit == '0') {current = current.left;} else if (bit == '1') {current = current.right;}if (current.left == null && current.right == null) {decodedText.append(current.data);current = root;}}return decodedText.toString();}}```请注意，这只是一个简单的示例，实际上Huffman编码可能涉及到更多的细节和考虑因素。
计算机应用基础数据压缩和解压缩的原理与方法
计算机应用基础数据压缩和解压缩的原理与方法数据压缩和解压缩在计算机应用中扮演着重要的角色，它可以有效地减少数据的存储空间和网络传输所需的带宽。
本文将介绍数据压缩和解压缩的原理与方法。
一、数据压缩的原理数据压缩的基本原理是通过消除冗余信息来减少数据的存储空间和传输带宽。
下面将介绍几种常见的数据压缩原理。
1.1 无损压缩无损压缩是指在数据压缩的过程中不会丢失原始数据的任何信息。
其中最常用的无损压缩算法是哈夫曼编码和LZW编码。
1.1.1 哈夫曼编码哈夫曼编码是一种变长编码，根据字符出现的频率来构建编码表。
频率较高的字符使用较短的编码，频率较低的字符使用较长的编码。
在压缩的过程中，将原始数据替换为对应的编码，从而减少数据的大小。
1.1.2 LZW编码LZW编码是一种字典编码，将一系列连续的字符序列映射为短的编码。
在压缩的过程中，使用一个字典来存储已经出现的字符序列及其对应的编码。
当遇到新的字符序列时，将其添加到字典中，并输出其对应的编码。
1.2 有损压缩有损压缩是指在压缩的过程中会有一定程度上的信息丢失。
有损压缩常用于图像、音频和视频等多媒体数据的压缩。
其中最常用的有损压缩算法是JPEG和MP3。
1.2.1 JPEGJPEG是一种常用的图像压缩格式，它通过舍弃图像中的一些高频信息来减少数据的大小。
在压缩的过程中，JPEG将图像分为不同的8x8像素块，并对每个块进行离散余弦变换（DCT），然后对DCT系数进行量化，并使用熵编码进行进一步压缩。
1.2.2 MP3MP3是一种常用的音频压缩格式，它通过删除音频中的一些听觉上不明显的信息来减少数据的大小。
在压缩的过程中，MP3首先对音频进行傅里叶变换，并将频谱分割为不同的子带。
然后对每个子带进行量化，并使用熵编码进行进一步压缩。
二、数据解压缩的原理数据解压缩的过程是数据压缩的逆过程，它可以将压缩后的数据恢复为原始的数据。
解压缩的原理和压缩的原理相对应，下面将介绍几种常见的数据解压缩原理。
哈夫曼编码解码 原理
哈夫曼编码解码原理
哈夫曼编码是一种前缀编码方法，它利用数据中出现频率高的字符用较短的编码表示，而将出现频率低的字符用较长的编码表示，从而达到压缩数据的目的。
哈夫曼编码的实现原理如下：
1. 统计每个字符在数据中出现的次数，并按照出现次数从小到大排序；
2. 将出现次数最少的两个字符合并为一个新的字符，其出现次数为这两个字符出现次数之和；
3. 将新字符加入字符集合中，并对字符集合重新排序；
4. 重复步骤2和3，直到字符集合中只剩下一个字符，该字符即为根节点，建立哈夫曼树；
5. 对哈夫曼树中的每个叶节点进行编码，从根节点出发，向左走为0，向右走为1，最终得到每个叶节点的哈夫曼编码；
6. 将数据中的每个字符替换为其哈夫曼编码，得到压缩后的数据。
哈夫曼编码的解码过程是通过哈夫曼树进行的，对于每个编码，从根节点出发，遇到0向左，遇到1向右，直至到达叶节点，即可得到原始字符。
哈夫曼文件压缩实验报告
哈夫曼文件压缩实验报告摘要：哈夫曼编码是一种常用的文件压缩算法，在本实验中我们通过使用哈夫曼编码算法对文件进行压缩和解压缩，来评估该算法在文件压缩方面的效果。
通过实验结果分析，我们发现哈夫曼编码能够有效地减小文件的大小，同时保持压缩后文件的可还原性。
1. 引言文件压缩是计算机科学领域的一个重要研究方向，它能够有效地减小文件的大小，节省存储空间和传输带宽。
哈夫曼编码作为一种经典的文件压缩算法，已被广泛应用于实际的文件压缩和传输中。
本实验旨在通过对哈夫曼编码的实际应用进行实验，评估其在文件压缩方面的效果。
2. 实验设计本实验分为三个步骤：文件读取、哈夫曼编码和压缩、解压和文件写入。
首先，我们需要从硬盘上读取待压缩的文件，并将其转化为二进制数据流。
接下来，我们使用哈夫曼编码算法对二进制数据流进行编码，生成编码后的数据流。
最后，我们根据编码表对编码后的数据流进行解码，恢复原始的二进制数据流，并将其写入硬盘上。
3. 实验过程首先，我们通过在计算机上选择一个待压缩的文件作为实验对象，然后设计一个程序来读取该文件的内容，并将其转化为二进制数据流。
为了保证实验结果的准确性，我们选择了不同类型和不同大小的文件进行实验，包括文本文件、图像文件和音频文件等。
接下来，我们使用哈夫曼编码算法对二进制数据流进行编码。
哈夫曼编码算法的核心思想是：将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，以达到最小化编码长度的效果。
在编码过程中，我们需要构建哈夫曼树和哈夫曼编码表。
哈夫曼树通过合并出现频率最低的两个节点来构建，最终生成一棵以根节点为基础的哈夫曼树。
哈夫曼编码表则是根据哈夫曼树的结构和编码规则生成的，将每个字符与对应的编码一一对应。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
利用哈夫曼编码实现压缩和解压缩1.问题描述利用哈夫曼编码，实现压缩和解压缩的数据元素具有如下形式:结点：weight:存储结点的权值parent:是结点双亲在向量中的下标lchild:结点的左儿子向量下标rchild:结点右儿子向量下标bits:位串，存放编码ch:字符start:编码在位串中的起始位置文件操作记录：b:记录字符在数组中的位置count:字符出现频率（权值）lch、rch、parent:定义哈夫曼树指针变量bits[256]:定义存储哈夫曼编码的数组2.功能需求对于给定的一组字符，可以根据其权值进行哈夫曼编码，并能输出对应的哈夫曼树和哈夫曼编码；实现哈夫曼解码。
能够分析文件，统计文件中出现的字符，再对文件进行编码，实现文件的压缩和解压缩，能够对于文件的压缩，比例进行统计，能够打印文件。
3.实现要点（1）构造哈弗曼树过程中，首先将初始森林的各根结点的双亲和左、右儿子指针置-1；叶子在向量T的前n个分量中，构成初始森林的n个结点；对森林中的树进行n次合并，并产生n-1个新结点，依次放入向量T的第i个分量中。
（2）编码过程中，从叶子T[i]出发，利用双亲的指针找到双亲T[p]；再根据T[p]的孩子指针可以知道T[i]是T[p]的左儿子还是右儿子，若是左儿子，则生成代码0，否则生成代码1；（3）在文件压缩和解压过程中，主要参考网上资料，每个步骤都基本理解，并注上了详细解析。
4．函数定义功能：输入权重，构造一棵哈弗曼树void huffman(hftree T){if(n<1 || n > m)return;int i,j,p1,p2;float small1,small2;//初始化cout<<"请输入叶子权重(5个)："<<endl;for(i=0; i<n; i++){T[i].parent = -1;T[i].lchild = T[i].rchild = -1;}//输入叶子权值for(i=0; i<n; i++){cin>>T[i].weight;}for(i=n; i<m; i++){p1 = p2 = -1;small1 = small2 = MAX_FLOAT;for(j=0; j<=i-1; j++){if(T[j].parent != -1)continue;if(T[j].weight < small1){small2 = small1;small1 = T[j].weight;p2 = p1;p1 = j;}else if(T[j].weight < small2){small2 = T[j].weight;p2 = j;}}T[p1].parent = T[p2].parent = i;T[i].parent=-1;T[i].lchild=p1;T[i].rchild=p2;T[i].weight=small1 + small2;}cout<<"创建成功！"<<endl;}功能：对哈弗曼树进行编码void encode(codelist codes, hftree T){int i,c,p,start;cout<<"请输入需要编码的字符(5个)："<<endl;for(i=0; i<n; i++){cin>>codes[i].ch;start=n;c=i;p=T[i].parent;while(p!=-1){start--;if(T[p].lchild==c) codes[i].bits[start]='0';else codes[i].bits[start]='1';c=p;p=T[p].parent;}codes[i].start=start;}cout<<"输入成功！："<<endl;cout<<"编码表:"<<endl;for(int x=0; x<n; x++){cout<<codes[x].ch<<": ";for(int q=codes[x].start;q<n;q++) cout<<codes[x].bits[q];cout<<endl;}}函数功能：对哈弗曼树进行解码void decode(codelist codes,hftree T){int i,c,p,b;int endflag;endflag=-1;i=m-1;while(cin>>b,b!=endflag){if(b==0) i=T[i].lchild;else i=T[i].rchild;if(T[i].lchild==-1){cout<<codes[i].ch;i=m-1;}}if(i!=m-1)cout<<"编码有错！\n"; }功能：对文件进行压缩，统计压缩率void compress(){char filename[255],outputfile[255],buf[512];unsigned char c;long i,j,m,n,f;long min1,pt1,flength,length1,length2; double div;FILE *ifp,*ofp;cout<<"\t请您输入需要压缩的文件：";cin>>filename;ifp=fopen(filename,"rb");if(ifp==NULL){cout<<"\n\t文件打开失败!\n\n";return;}cout<<"\t请您输入压缩后的文件名：";cin>>outputfile;ofp=fopen(strcat(outputfile,".encode"),"wb");if(ofp==NULL){cout<<"\n\t压缩文件失败!\n\n";return;}flength=0;while(!feof(ifp)){fread(&c,1,1,ifp);header[c].count++; //字符重复出现频率+1flength++; //字符出现原文件长度+1 }flength--;length1=flength; //原文件长度用作求压缩率的分母header[c].count--;for(i=0;i<512;i++){if(header[i].count!=0) header[i].b=(unsigned char)i;else header[i].b=0;header[i].parent=-1;header[i].lch=header[i].rch=-1; //对结点进行初始化}for(i=0;i<256;i++) //根据频率（权值）大小，对结点进行排序，选择较小的结点进树{for(j=i+1;j<256;j++){if(header[i].count<header[j].count){tmp=header[i];header[i]=header[j];header[j]=tmp;}}}for(i=0;i<256;i++) if(header[i].count==0) break;n=i; //外部叶子结点数为n个时，部结点数为n-1，整个哈夫曼树的需要的结点数为2*n-1.m=2*n-1;for(i=n;i<m;i++) //构建哈夫曼树{min1=999999999; //预设的最大权值，即结点出现的最大次数for(j=0;j<i;j++){if(header[j].parent!=-1) continue;//parent!=-1说明该结点已存在哈夫曼树中，跳出循环重新选择新结点*/if(min1>header[j].count){pt1=j;min1=header[j].count;continue;}}header[i].count=header[pt1].count;header[pt1].parent=i; //依据parent域值（结点层数）确定树中结点之间的关系header[i].lch=pt1; //计算左分支权值大小min1=999999999;for(j=0;j<i;j++){if(header[j].parent!=-1) continue;if(min1>header[j].count){pt1=j;min1=header[j].count;continue;}}header[i].count+=header[pt1].count;header[i].rch=pt1; //计算右分支权值大小header[pt1].parent=i;}for(i=0;i<n;i++) //哈夫曼无重复前缀编码{f=i;header[i].bits[0]=0; //根结点编码0while(header[f].parent!=-1){j=f;f=header[f].parent;if(header[f].lch==j) //置左分支编码0{j=strlen(header[i].bits);memmove(header[i].bits+1,header[i].bits,j+1);//依次存储连接“0”“1”编码header[i].bits[0]='0';}else //置右分支编码1{j=strlen(header[i].bits);memmove(header[i].bits+1,header[i].bits,j+1);header[i].bits[0]='1';}}}fseek(ifp,0,SEEK_SET); //从文件开始位置向前移动0字节，即定位到文件开始位置fwrite(&flength,sizeof(int),1,ofp);fseek(ofp,8,SEEK_SET);buf[0]=0; //定义缓冲区,它的二进制表示00000000f=0;pt1=8;while(!feof(ifp)){c=fgetc(ifp);f++;for(i=0;i<n;i++){if(c==header[i].b) break;strcat(buf,header[i].bits);j=strlen(buf);c=0;while(j>=8) //对哈夫曼编码位操作进行压缩存储{for(i=0;i<8;i++){if(buf[i]=='1') c=(c<<1)|1;else c=c<<1;}fwrite(&c,1,1,ofp);pt1++; //统计压缩后文件的长度strcpy(buf,buf+8); //一个字节一个字节拼接j=strlen(buf);}if(f==flength) break;}if(j>0) //对哈夫曼编码位操作进行压缩存储{strcat(buf,"00000000");for(i=0;i<8;i++)if(buf[i]=='1') c=(c<<1)|1;else c=c<<1;}fwrite(&c,1,1,ofp);pt1++;}fseek(ofp,4,SEEK_SET);fwrite(&pt1,sizeof(long),1,ofp);fseek(ofp,pt1,SEEK_SET);fwrite(&n,sizeof(long),1,ofp);for(i=0;i<n;i++){fwrite(&(header[i].b),1,1,ofp);c=strlen(header[i].bits);fwrite(&c,1,1,ofp);j=strlen(header[i].bits);if(j%8!=0) //若存储的位数不是8的倍数，则补0 {for(f=j%8;f<8;f++)strcat(header[i].bits,"0");}while(header[i].bits[0]!=0){c=0;for(j=0;j<8;j++) //字符的有效存储不超过8位，则对有效位数左移实现两字符编码的连接{if(header[i].bits[j]=='1') c=(c<<1)|1; //|1不改变原位置上的“0”“1”值else c=c<<1;}strcpy(header[i].bits,header[i].bits+8); //把字符的编码按原先存储顺序连接fwrite(&c,1,1,ofp);}}length2=pt1--;div=((double)length1-(double)length2)/(double)length1; //计算文件的压缩率fclose(ifp);fclose(ofp);printf("\n\t压缩文件成功!\n");printf("\t压缩率为%f%%\n\n",div*100);return;}函数功能：对文件解压缩void uncompress(){char filename[255],outputfile[255],buf[255],bx[255];unsigned char c;long i,j,m,n,f,p,l;long flength;FILE *ifp,*ofp;cout<<"\t请您输入需要解压缩的文件：";cin>>filename;ifp=fopen(strcat(filename,".encode"),"rb");if(ifp==NULL){cout<<"\n\t文件打开失败!\n";return;}cout<<"\t请您输入解压缩后的文件名：";cin>>outputfile;ofp=fopen(outputfile,"wb");if(ofp==NULL){cout<<"\n\t解压缩文件失败!\n";return;}fread(&flength,sizeof(long),1,ifp); //读取原文件长度，对文件进行定位fread(&f,sizeof(long),1,ifp);fseek(ifp,f,SEEK_SET);fread(&n,sizeof(long),1,ifp);for(i=0;i<n;i++){fread(&header[i].b,1,1,ifp);fread(&c,1,1,ifp);p=(long)c; //读取原文件字符的权值header[i].count=p;header[i].bits[0]=0;if(p%8>0) m=p/8+1;else m=p/8;for(j=0;j<m;j++){fread(&c,1,1,ifp);f=c;itoa(f,buf,2); //将f转换为二进制表示的字符串f=strlen(buf);for(l=8;l>f;l--){strcat(header[i].bits,"0");}strcat(header[i].bits,buf);}header[i].bits[p]=0;}for(i=0;i<n;i++) //根据哈夫曼编码的长短，对结点进行排序{for(j=i+1;j<n;j++){if(strlen(header[i].bits)>strlen(header[j].bits)){tmp=header[i];header[i]=header[j];header[j]=tmp;}}}p=strlen(header[n-1].bits);fseek(ifp,8,SEEK_SET);m=0;bx[0]=0;while(1) //通过哈夫曼编码的长短，依次解码，从原来的位存储还原到字节存储{while(strlen(bx)<(unsigned int)p){fread(&c,1,1,ifp);f=c;itoa(f,buf,2);f=strlen(buf);for(l=8;l>f;l--) //在单字节对相应位置补0{strcat(bx,"0");}strcat(bx,buf);}for(i=0;i<n;i++){if(memcmp(header[i].bits,bx,header[i].count)==0) break;}strcpy(bx,bx+header[i].count);c=header[i].b;fwrite(&c,1,1,ofp);m++; //统计解压缩后文件的长度if(m==flength) break; //flength是原文件长度}fclose(ifp);fclose(ofp);cout<<"\n\t解压缩文件成功!\n";if(m==flength) //对解压缩后文件和原文件相同性比较进行判断（根据文件大小）cout<<"\t解压缩文件与原文件相同!\n\n";else cout<<"\t解压缩文件与原文件不同!\n\n";return;}5、总结和体会本次大作业与C++大作业有所不同，主要是利用构造数据结构解决问题，C++大作业主要体现类和文件读写功能。