Huffman压缩解压的思考

最新推荐文章于 2022-09-05 17:04:16 发布
最新推荐文章于 2022-09-05 17:04:16 发布
阅读量5.1k 收藏 1
点赞数
分类专栏： C++ 文章标签： string null java 算法 byte 数据结构

转自于http://imba-marlboro.iteye.com/blog/889143

历时10多天，文件压缩终于能用了。从最开始的构造huffman树到最后的解压缩，遇到了不少纠结的难题。下面就和大家分享一下做文件压缩的心得。 

          1.构建huffman树。由于数据结构基础有限，也想不到高明的压缩方法，便只能用书上的一种简单而实用的方法---huffman编码。Huffman树是一种特殊的二叉树，我把构建它分成了4部，建立了4个方法：
          a. 统计传入数据中每个字符出现的次数，这个数据可以是一个文件，也可以是一个字符串。 字符作为key，次数作为value存入一个map中。
          b.将上面得到的map作为参数，建立一个由TreeNode组成的 ArrayList其中map的key值作为TreeNode的flag，map中的value作为TreeNode的weight。
          c.上面一步便得到了由huffman树叶子节点组成的ArrayList，然后就是建树了，由于huffman树的叶结点的个数为n，那么它的中间结点的个数肯定是n-1，由次每次对ArrayList由小到大排序，取出前面的最小值和次小值，新建一个结点，对这3个结点进行连接，然后新节点入队，前面两个出队，循环n-1次最终可得到连接好的huffman树。
          d.将得到的huffman树进行编码，得到编好码的huffman树。
          这4步c和d是最难的，d步的代码想了很久也没有想出来，最后还是问了别人才搞到递归算法，后来自己还设计了一种非递归的算法，递归和非递归的代码如下：
Java代码 复制代码  收藏代码
  1. /**  
  2.   * 先序遍历huffman树,并得到其编码（递归算法）  
  3.   * @param root: 要遍历的huffman树  
  4.   * @param hfmCode: 所遍历结点的huffman编码  
  5.   */  
  6. public void preVisitTree(TreeNode root , String hfmCode){   
  7.     //如果根不为0   
  8.     if(root != null){   
  9.         root.setHuffmanCode(hfmCode);   
  10.         String lCode = hfmCode + "0";   
  11.         preVisitTree(root.getLchild() , lCode);   
  12.         String rCode = hfmCode+"1";   
  13.         preVisitTree(root.getRchild() , rCode);   
  14.     }   
  15. }  
/**
  * 先序遍历huffman树,并得到其编码（递归算法）
  * @param root: 要遍历的huffman树
  * @param hfmCode: 所遍历结点的huffman编码
  */
public void preVisitTree(TreeNode root , String hfmCode){
	//如果根不为0
	if(root != null){
		root.setHuffmanCode(hfmCode);
		String lCode = hfmCode + "0";
		preVisitTree(root.getLchild() , lCode);
		String rCode = hfmCode+"1";
		preVisitTree(root.getRchild() , rCode);
	}
}

Java代码 复制代码  收藏代码
  1. /**  
  2.   * 非递归获取哈夫曼编码  
  3.   * @param root: 哈夫曼树根节点  
  4.   */  
  5. public void setHfmCode(TreeNode root){   
  6.     java.util.ArrayList<TreeNode> treeList = new java.util.ArrayList<TreeNode>();   
  7.     treeList.add(root);   
  8.     TreeNode tempNode;//临时引用   
  9.     String hfmCode = "";   
  10.     //对huffman树层次遍历   
  11.     while(!treeList.isEmpty()){   
  12.         tempNode = treeList.remove(0);//头元素出队进行运算   
  13.         hfmCode = tempNode.getHuffmanCode();   
  14.         if(tempNode.getLchild() != null){   
  15.             treeList.add(tempNode.getLchild());   
  16.             hfmCode = tempNode.getHuffmanCode();   
  17.             tempNode.getLchild().setHuffmanCode(hfmCode + "0");   
  18.         }   
  19.         if(tempNode.getRchild() != null){   
  20.             treeList.add(tempNode.getRchild());   
  21.             hfmCode = tempNode.getHuffmanCode();   
  22.             tempNode.getRchild().setHuffmanCode(hfmCode + "1");   
  23.         }   
  24.     }   
  25. }  
/**
  * 非递归获取哈夫曼编码
  * @param root: 哈夫曼树根节点
  */
public void setHfmCode(TreeNode root){
	java.util.ArrayList<TreeNode> treeList = new java.util.ArrayList<TreeNode>();
	treeList.add(root);
	TreeNode tempNode;//临时引用
	String hfmCode = "";
	//对huffman树层次遍历
	while(!treeList.isEmpty()){
		tempNode = treeList.remove(0);//头元素出队进行运算
		hfmCode = tempNode.getHuffmanCode();
		if(tempNode.getLchild() != null){
			treeList.add(tempNode.getLchild());
			hfmCode = tempNode.getHuffmanCode();
			tempNode.getLchild().setHuffmanCode(hfmCode + "0");
		}
		if(tempNode.getRchild() != null){
			treeList.add(tempNode.getRchild());
			hfmCode = tempNode.getHuffmanCode();
			tempNode.getRchild().setHuffmanCode(hfmCode + "1");
		}
	}
}
     
         2.压缩文件到指定目录。至此，压缩的第一部就已经完成，我们得到了一个由file中所有字节作为flag，其个数作为weight的带huffman编码的树。
          我们压缩后的文件应该分为两部分：码表和压缩体。
          码表是一个由字节作为key，字节对应的huffman编码作为value的map对象。个人认为如果将码表压缩在文件前端，对解压缩应该要方便一些。因为解压缩一开始就可以把码表读出来保存在map对象中。码表压缩时第一位应该保存一个int值，是map的size()。而且压缩码表的时候可以用一个小技巧，压缩时的码表是map<Byte , String>由于解压缩是是用字符串找字节，而map中的方法containsKey()和get()都只能是由key值找value值，为了方便可以先存value(String)再存key(Byte)，当然也可以先存key(Byte)再存value(String)上一部就留给解压缩码表时完成。值得注意的是无论先存什么，为了后来操作方便都应该在存入String前存入一个int值是这个String(huffman)编码的长度。
      压缩压缩体的时候也有许多小技巧，为了方便操作，第一个存入的数据可以是这个压缩体的大小。而第二个则是字符串末尾补零的个数，因为将文件的所有字节转换为一个字符串，这个串不一定就是8的倍数，最后很有可能要补0，为此我专门写了一个方法来计算压缩体的大小和补零的个数，利用的则是层次遍历第一部的到的huffman树，代码如下：
Java代码 复制代码  收藏代码
  1. /**  
  2.   * 得到补零的个数和压缩后文件的字节数   
  3.   * @param src:源文件地址  
  4.   * @param root:压缩用huffman树根节点  
  5.   */  
  6. public void getCompressInfo(String src, TreeNode root) {   
  7.     // 辅助计数器   
  8.     int tempCount = 0;    
  9.     // 建立一个结点队列   
  10.     java.util.ArrayList<TreeNode> treeList = new java.util.ArrayList<TreeNode>();   
  11.     treeList.add(root);    
  12.     TreeNode tempNode;// 临时变量   
  13.     while (!treeList.isEmpty()) {   
  14.         tempNode = treeList.remove(0);   
  15.         // 如果是叶子结点,则累加其1,0个数   
  16.         if (tempNode.getLchild() == null && tempNode.getRchild() == null) {   
  17.             // 统计补零个数   
  18.             numOfZero += tempNode.getWeight() * tempNode.getHuffmanCode().length();   
  19.             numOfZero = numOfZero % 8;   
  20.             // 统计字节数   
  21.             tempCount += tempNode.getWeight() * tempNode.getHuffmanCode().length();   
  22.             count += tempCount / 8;   
  23.             tempCount = tempCount % 8;   
  24.         }   
  25.         // 如果有左右孩子则入队   
  26.         if (tempNode.getLchild() != null) {   
  27.             treeList.add(tempNode.getLchild());   
  28.         }   
  29.         if (tempNode.getRchild() != null) {   
  30.             treeList.add(tempNode.getRchild());   
  31.         }   
  32.     }   
  33.     if (tempCount != 0) {   
  34.         count++;   
  35.     }   
  36.     numOfZero = 8 - numOfZero;   
  37. }  
/**
  * 得到补零的个数和压缩后文件的字节数 
  * @param src:源文件地址
  * @param root:压缩用huffman树根节点
  */
public void getCompressInfo(String src, TreeNode root) {
	// 辅助计数器
	int tempCount = 0; 
	// 建立一个结点队列
	java.util.ArrayList<TreeNode> treeList = new java.util.ArrayList<TreeNode>();
	treeList.add(root); 
	TreeNode tempNode;// 临时变量
	while (!treeList.isEmpty()) {
		tempNode = treeList.remove(0);
		// 如果是叶子结点,则累加其1,0个数
		if (tempNode.getLchild() == null && tempNode.getRchild() == null) {
			// 统计补零个数
			numOfZero += tempNode.getWeight() * tempNode.getHuffmanCode().length();
			numOfZero = numOfZero % 8;
			// 统计字节数
			tempCount += tempNode.getWeight() * tempNode.getHuffmanCode().length();
			count += tempCount / 8;
			tempCount = tempCount % 8;
		}
		// 如果有左右孩子则入队
		if (tempNode.getLchild() != null) {
			treeList.add(tempNode.getLchild());
		}
		if (tempNode.getRchild() != null) {
			treeList.add(tempNode.getRchild());
		}
	}
	if (tempCount != 0) {
		count++;
	}
	numOfZero = 8 - numOfZero;
}

     存好这两个数据以后则将源文件中的字节一个个的读出来，读出一个，从map中找到其对应的huffmanCode，一步步累加，当这个huffmanCode大于等于8的时候则将前八位转换成一个int(这里可以自己写方法也可以用效率更高的Java API方法Integer.parseInt)，写入后八位。然后截取掉前八位，这两个步骤都可以用String类中的substring方法。
3.将文件解压缩。 解压缩是压缩的逆过程，但比压缩更加纠结。解压缩第一步就是读出码表将其保存如一个map<String , Byte>中。
读完码表后便可以对压缩体解压。解压时需要注意的是要和压缩时压缩进去的数据一一对应。错一点点就会产生蝴蝶效应，全部解错。另外和压缩一样，解压缩也可以读一个换成String然后在码表中找到对应的字节，剩下的找不到的前加到下一个String，其中最要注意的就是在用Integer.toBinaryString时，前面位的0可能丢失，如果得到的字符串不足八位，则前面一定要补零。实现这一步的关键代码如下：
Java代码 复制代码  收藏代码
  1. // 处理前面所有未补零的字节   
  2. while (count > 1) {   
  3.     b = dis.read();//从压缩文件中读取第一个压缩体的字节      String tempStr = Integer.toBinaryString(b);// 得到压缩后的字节，并将其转化为字符串   
  4.     int strLen = tempStr.length();//如果tempStr不足八位.前面补零   
  5.     if(strLen < 8){   
  6.         for(int i = 0 ; i < 8-strLen ; i++){   
  7.             tempStr = "0" + tempStr;   
  8.         }   
  9.     }   
  10.     str = str + tempStr;   
  11.     count--;   
  12.     // 一位一位的查找map中是否由对应的字节,有则写入   
  13.     while (str.length() != 0) {   
  14.         if (str.length() == 1) {   
  15.             firstCode += str;   
  16.             str = "";   
  17.         }   
  18.         if (str.length() > 1) {   
  19.             firstCode += str.substring(0, 1);   
  20.             str = str.substring(1);   
  21.         }   
  22.         if (map.containsKey(firstCode)) {   
  23.             dos.write(map.get(firstCode));// 得到串对应的value值，并写入   
  24.             firstCode = "";// 将firstCode重新初始化   
  25.         }   
  26.     }   
  27. }   
  28.   
  29. if(numOfZero != 0){//处理最后的补零位   
  30.     b = dis.read();   
  31.     String tempStr = Integer.toBinaryString(b);   
  32.     if(tempStr.length() < 8){   
  33.         int k = 8 - tempStr.length();   
  34.         for(int i = 0 ; i < k ; i++){   
  35.             tempStr = "0" + tempStr;   
  36.         }   
  37.     }   
  38.     tempStr = tempStr.substring(0,8 - numOfZero);   
  39.     str = str+tempStr;   
  40.     for(int i = 0 ; i < tempStr.length() ; i++){   
  41.         // 一位一位的查找map中是否由对应的字节,有则写入   
  42.         if(str.length() == 1){   
  43.             firstCode += str;   
  44.             str = "";   
  45.         }   
  46.         if (str.length() > 1) {   
  47.             firstCode += str.substring(0,1);   
  48.             str = str.substring(1);   
  49.         }   
  50.         if (map.containsKey(firstCode)) {   
  51.             dos.write(map.get(firstCode));// 得到串对应的value值，并写入   
  52.             firstCode = "";// 将firstCode重新初始化   
  53.         }   
  54.     }   
  55. }  
// 处理前面所有未补零的字节
while (count > 1) {
	b = dis.read();//从压缩文件中读取第一个压缩体的字节		String tempStr = Integer.toBinaryString(b);// 得到压缩后的字节，并将其转化为字符串
	int strLen = tempStr.length();//如果tempStr不足八位.前面补零
	if(strLen < 8){
		for(int i = 0 ; i < 8-strLen ; i++){
			tempStr = "0" + tempStr;
		}
	}
	str = str + tempStr;
	count--;
	// 一位一位的查找map中是否由对应的字节,有则写入
	while (str.length() != 0) {
		if (str.length() == 1) {
			firstCode += str;
			str = "";
		}
		if (str.length() > 1) {
			firstCode += str.substring(0, 1);
			str = str.substring(1);
		}
		if (map.containsKey(firstCode)) {
			dos.write(map.get(firstCode));// 得到串对应的value值，并写入
			firstCode = "";// 将firstCode重新初始化
		}
	}
}

if(numOfZero != 0){//处理最后的补零位
	b = dis.read();
	String tempStr = Integer.toBinaryString(b);
	if(tempStr.length() < 8){
		int k = 8 - tempStr.length();
		for(int i = 0 ; i < k ; i++){
			tempStr = "0" + tempStr;
		}
	}
	tempStr = tempStr.substring(0,8 - numOfZero);
	str = str+tempStr;
	for(int i = 0 ; i < tempStr.length() ; i++){
		// 一位一位的查找map中是否由对应的字节,有则写入
		if(str.length() == 1){
			firstCode += str;
			str = "";
		}
		if (str.length() > 1) {
			firstCode += str.substring(0,1);
			str = str.substring(1);
		}
		if (map.containsKey(firstCode)) {
			dos.write(map.get(firstCode));// 得到串对应的value值，并写入
			firstCode = "";// 将firstCode重新初始化
		}
	}
}

     由这三步，压缩基本就可以实现了，在这次做压缩的过程中，遇到了许多的bug，我们应当直面惨淡的bug，不断的System.out.println()测试每一步数据，找到他再仔细思考，找到一个修改一个。让写出的程序可以针对每一种特殊情况的发生。  
doupei2006
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
完成基于哈夫曼树（最优二叉树）的压缩及解压小程序的收获
Mc_Id的专栏
07-16 1452
收获      1） 更有条理的构造我的代码了： 先从main方法下手，将自己想要的实现程序的功能以注释 的方式写出来，然后再逐渐细化每一部分的功能，每部分的功能都有非常明确的输入部分，将这些输入的内容加工，进行输出（也就是下一部分功能的实现的输入部分）就是这部分功能的全部内容，每一部分功能都实现，程序就完成了。 2）学会使用DeBug来检验自己程序的执行结果：        
Huffman压缩
慢慢来会比较快
04-06 2982
Huffman编码的Java实现，对数据的压缩和解压缩的过程做了分析和代码和代码实现，主要涉及到二叉树这种数据结构和一些数据处理方法
哈夫曼压缩总结
lixiongzhi_lxz的专栏
07-31 357
实现哈弗曼压缩的步骤： [color=red]一.读取文件[/color] 保存每一个字符对应的出现次数，该步骤利用数组和字符对应的ACISS值来存储，字符对应的ACISS值作为数组的下标，字符没出现一次，相应下标的数组元素加一。 代码如下： [code="java"]try { // 实例化文件输入流对象 FileInputStream fis = ne...
一些无损压缩算法的使用和心得（哈夫曼，lzo）
qq_62256091的博客
09-05 955
一些无损压缩算法的使用和心得（哈夫曼，lzo）
哈夫曼压缩与解压缩学习笔记（一）
心中的利剑：HTML5 Canvas游戏动画（JavaScript）
10-28 223
前言 看了两个哈夫曼压缩程序,学习了一把,选一个压缩和解压缩效率高的作些笔记. 一、哈夫曼压缩原理 我们知道计算机中的文件采用二进制编码，为了使文件尽可能的缩短(压缩)，可以对文件中每个字节出现的次数进行统计,设法让出现次数多的字节的二进制码短些，而让那些很少出现的字节的二进制码长一些,这便使整个文件编码之后的总长度的平均期望长度降低，从而达到无损压缩数据的目的。哈夫曼uf...
基于哈夫曼编码完成的文件压缩及解压
weixin_30820077的博客
04-25 1244
这几天在较为认真的研究基于哈夫曼编码的文件压缩及解压，费了点时间，在这分享一下： 这里用链式结构，非顺序表结构； 文件压缩： 1.获取文件信息（这里采用TXT格式文本）； 2.压缩文件； 3.写配置文件（便于解压时用，无非就是存放原文件的索引之类的，比如说，文件中某个字符出现的个数，记录下来） 4.解压缩，使用压缩后的文件和配置文件解压文件； 5.用比对软件，...
Huffman压缩算法
weixin_39647415的博客
09-19 246
霍夫曼和自适应的霍夫曼是编码的例子，它利用符号概率的统计偏斜，将其编码为尽可能少的位。（还有其他类型的编码，如算术、范围和不对称数字系统。 Lempel-Ziv 是建模的一个例子，它采用在压缩的特定类型的数据中发现的冗余，在此例文本中，并将其转换为一系列适合编码的符号。Lempel-Ziv 的工作假设是，文本中不会重复不同长度的字符串，这是自然语言的案例。 这种假设根本不适用于音频或图像文件，因为冗余的形式非常不同。在数据上执行转换，以按频率将组件分离出来，作为建模的一部分。此外，人类消费的音频和图像数据也
Huffman压缩解压java实现
07-02
Huffman编码是一种基于字符频率的无损数据压缩算法，由美国计算机科学家David A. Huffman在1952年提出。它的核心思想是构建一棵特殊的二叉树，即Huffman树，来对数据进行编码。在Java中实现Huffman编码，需要理解其...
huffman_code.rar_Huffman压缩_huffman解压
07-14
在这个“huffman_code.rar”压缩包中，包含的是用MATLAB语言实现的哈夫曼压缩和解压算法。 哈夫曼编码的核心思想是：频繁出现的字符用较短的编码表示，不常出现的字符用较长的编码表示。通过构建一棵特殊的二叉树...
Huffman压缩解压
05-21
在C++11中实现Huffman压缩解压涉及到多个关键概念和技术，下面将详细阐述这些知识点。 1. **Huffman树（Huffman Tree）**：Huffman树是Huffman编码的基础，它是一种特殊的二叉树，也称为最优二叉树。在构建Huffman...
用哈夫曼算法实现字符型文件压缩与解压(实验报告)
12-24
用哈夫曼算法实现字符型文件压缩与解压，采用C语言实现，友好界面，适合初学者参考和模仿。 适合作为数据结构与算法分析的实验对象。
使用Huffman对文件进行压缩和解压缩
01-12
使用java语言实现Huffman对任意文件做到压缩和解压缩，压缩后的文件只能通过解压缩来解压后才能读取
用哈夫曼编码实现文件压缩（代码+报告）
04-04
数据结构课程设计用哈夫曼编码实现文件压缩： 一、实验题目： 用哈夫曼编码实现文件压缩 二、实验目的： 1、了解文件的概念。 2、掌握线性链表的插入、删除等算法。 3、掌握Huffman树的概念及构造方法。 4、掌握二叉树的存储结构及遍历算法。 5、利用Huffman树及Huffman编码，掌握实现文件压缩的一般原理。 三、实验设备与环境： 微型计算机、Windows 系列操作系统 、Visual C++6.0软件 四、实验内容： 根据ASCII码文件中各ASCII字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。 五、概要设计： 1、数据结构类型定义 /*****Huffman结构定义**********/ typedef struct node { long w;//w为权值 short p,l,r; //p为parent，l为左孩子，r为右孩子 }htnode,*htnp;//动态分配数组存储哈夫曼树 /*****Huffman编码表结构定义*****/ typedef struct huffman_code { unsigned char len;//长度 unsigned char *codestr; }hufcode; typedef char **huffmancode;//动态分配数组存储哈夫曼编码表 2、本程序的构成，共有14个函数，一个菜单函数 int initial_files(char *source_filename,FILE **inp,char *obj_filename,FILE **outp); //1.初始化文件名 char *create_filename(char *source_filename,char* obj_filename); //2.创建文件名 int compress(char *source_filename,char *obj_filename); //3.压缩文件
huffman压缩.zip_Huffman压缩
07-14
用huffman实现对文件的压缩，解压缩
huffman编码实现压缩与解压文件
02-20
5. **保存编码表**：编码后的文件需要保留Huffman编码表以便解压。编码表可以存储为额外的字节流，或者通过某种方式编码到压缩文件的开头。 6. **解压缩**：解压缩时，首先读取并重建Huffman编码表。然后，按照编码...
HaffManTree哈夫曼树的编码和解码的个人学习心得感悟
热门推荐
寒雪无痕
05-20 2万+
HaffManTree哈夫曼树的编码和解码的个人学习心得感悟
哈夫曼压缩的小感受
RUNnidaren的专栏
11-17 1293
在基本了解哈夫曼压缩解压的原理后以为实现自己的代码是很容易的，故而一口气便基本写完才去检测，结果我快哭了。。。。然后结合自己写的感悟和小伙伴们的讨论，感觉有了一种做个小结的冲动！ （一）细节真可怕，写的时候一定要谨慎 a.压缩后的文件一直为空，然后弱智的发现打开方式。。。 b.fread（buffer, 每个对象大小，  读取次数, fp ）在读取一个不够相应操作大小的数据时自然是读不到了。
基于哈夫曼编码对文件进行压缩和解压缩（详细讲解）
lizefeng1998的博客
04-08 2万+
基于哈夫曼编码对文件进行压缩和解压缩（详细讲解） 本文对应c++代码实现链接 一、背景 利用特定的算法来压缩数据的工具，压缩后生成的文件称为压缩包。如果想使用其中的数据，就得用压缩软件对数据进行解压。利用压缩软件对文件中重复的数据进行压缩，可以减小文件中的字节总数，常用的压缩软件有rar、zip等。 二、编码介绍 2.1 等长编码 任何文件在计算中都是以字节为最小单位进行存储的，所以可以把任何文件看作是利用8位（一个字节）作为等长编码编码方式，编码而成的文件。往往这种编码方式并不是最优的编码方式。 例如：对
哈夫曼树实现文件的压缩与解压缩
深海一诺
03-08 1万+
利用哈夫曼树实现文件的压缩与解压缩 压缩： 1、统计出文件中相同字符出现的次数 2、获取哈夫曼编码 次数作为权值构建哈夫曼树 3、重新编码，写回压缩文件 保存头文件： 源文件后缀 编码信息的行数 每个字符的权
文件的压缩与解压huffman算法功能实现.pdf
最新发布
11-12
"文件的压缩与解压huffman算法功能实现.pdf" 本文主要探讨了文件的压缩与解压缩技术，特别是...通过需求分析、设计和测试等步骤，可以实现一个高效可靠的Huffman压缩和解压缩工具，以适应互联网时代的数据处理需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值