索引
一、明确功能
1、基础功能
将一串字符串"i like like like java do you like a java"利用霍夫曼编码原理进行压缩,并解压(即还原)。
2、扩展功能
进一步引入文件读写操作,对给定的图片或者文本文件,对其进行压缩,并将压缩的文件,重新恢复成原来的文件。
二、算法原理
1、霍夫曼树基本介绍
- 霍夫曼树定义
给定n个权值作为n个叶子结点,构造一棵二叉树,若该树的带权路径长度(wpl)达到最小,称这样的二叉树为最优二叉树,即霍夫曼树(Huffman Tree)。霍夫曼树是带权路径长度最短的树,权值较大的结点离根较近。 - 路径和路径长度:
在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1。 - 结点的权及带权路径长度
若将树中结点赋给一个有着某种含义的数值,则这个数值称为该结点的权。结点的带权路径长度(weighted path length)为:从根结点到该结点之间的路径长度与该结点的权的乘积。如下图三种建树方式,图二实现的带权路径长度最小,wpl为59.
2、霍夫曼树的创建思路
1、从小到大进行排序, 将每一个数据,每个数据都是一个节点 , 每个节点可以看成是一颗最简单的二叉树;
2、取出根节点权值最小的两颗二叉树
3、组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和 ;
3、再将这颗新的二叉树,以根节点的权值大小再次排序,不断重复 1-2-3-4 的步骤,直到数列中,所有的数据都被处理,就得到一颗赫夫曼树。
霍夫曼树的代码实现
要求:将数列 {13, 7, 8, 3, 29, 6, 1}转成一颗赫夫曼树。注意:因为数组是无法直接操作的,因此要先创建树的结点类Node。
package chuchu.huffmantree;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class HuffManTreeDemo {
public static void main(String[] args) {
int[] arr={
13,7,8,3,29,6,1};
Node root=huffmantree(arr);
Preorder(root);//前序遍历
}
//将数组传进去,返回来的是搭建好的树的根节点
public static Node huffmantree(int[] arr){
List<Node> nodes=new ArrayList<Node>();
for(int item:arr){
Node cur=new Node(item);
nodes.add(cur);
}
while(nodes.size()>1){
Collections.sort(nodes);//先排序
//System.out.println("nodes"+nodes);
//得到权值最小的两个节点
Node leftnode=nodes.get(0);
Node rightnode=nodes.get(1);
Node parent=new Node(leftnode.value+rightnode.value);
//构建一颗新的二叉树
parent.left=leftnode;
parent.right=rightnode;
//删除旧节点,将新生成的节点加入
nodes.remove(leftnode);
nodes.remove(rightnode);
nodes.add(parent);
}
return nodes.get(0);//返回整棵树的根节点
}
public static void Preorder(Node root){
if(root!=null){
root.preOreder();
}else{
System.out.println("空");
}
}
}
//为了让Node对象支持排序Collections集合排序,让Node实现Comparable接口
class Node implements Comparable<Node>{
int value;//节点权值
Node left;//左子节点
Node right;//右子节点
public Node(int value){
this.value=value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
@Override
public int compareTo(Node o) {
//表示从小到大排序
return this.value-o.value;
//若表示从大到小排序
//return -(this.value-o.value);
}
//二叉树的前序遍历
public void preOreder(){
System.out.println(this);//先输出当前节点
if(this.left!=null){
this.left.preOreder();//处理左子节点
}
if(this.right!=null){
this.right.preOreder();//处理右子节点
}
}
}
3、霍夫曼编码
- i like like like java do you like a java // 共40个字符(包括空格)
- d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9 // 统计各个字符对应的个数
- 按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值;
- 根据赫夫曼树,给各个字符规定编码 ,向左的路径为0,向右的路径为1,编码如下:
o: 1000 u: 10010 d: 100110 y: 100111 i: 101 a : 110 k: 1110 e: 1111
j: 0000 v: 0001 l: 001 (空格): 01 - 按照上面的赫夫曼编码,我们的"i like like like java do you like a java" 字符串对应的编码为:
1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110
长度为 : 133
说明:原来长度是359 , 压缩了 (359-133) / 359 = 62.9%
注意:此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性。
三、实现思路
1、实现对字符串的压缩编码
1、首先将字符串转为字节数组byte[],这一步很好实现,用getBytes()方法即可。
String content="i like like like java do you like a java";
byte[] contentbytes=content.getBytes();
2、为实现霍夫曼编码,需要创建霍夫曼树。
(1)首先创建节点类:treeNode:
//构建节点类
class treeNode implements Comparable<treeNode>{
Byte data;//存放的数据
int value;//节点权值
treeNode left;//左子节点
treeNode right;//右子节点
public treeNode(Byte data, int value) {
this.data = data;
this.value = value;
}
@Override
public String toString() {
return "treeNode{" +
"data=" + data +
", value=" + value +
'}';
}
@Override
public int compareTo(treeNode o) {
//表示从小到大排序
return this.value-o.value;
//若表示从大到小排序
//return -(this.value-o.value);
}
//前序遍历
public void preOreder(){
System.out.println(this);
if(this.left!=null){
this.left.preOreder();
}
if(this.right!=null){
this.right.preOreder();
}
}
}
(2)遍历byte[]数组,统计每个字符出现的次数,并将“字符->次数”作为键值(data->weight)转化为treeNode类型,并存入nodes集合中。
public static List<treeNode> getList(byte[] contentbytes){
ArrayList<treeNode> nodes=new ArrayList<treeNode>();
//遍历bytes,统计每个byte出现的次数
Map<Byte,Integer>counts=new HashMap<>();
for(byte item:contentbytes){
Integer count=counts.get(item);//寻找Map中item对应的value
if(count==null){
//说明这个count还不存在
counts.put(item,1);
}else {
counts.put(item,count+1);
}
}
//把每对键值转化为treeNode并存入nodes集合中
//遍历Map
for(Map.Entry<Byte,Integer>entry:counts.entrySet()){
nodes.add(new treeNode(entry.getKey(),entry.getValue()));
}
return nodes;
}
(3)构建赫夫曼树,原理上面已经讲过,这里有必要注意的是:非叶子节点是没有存放数据的,即data为null。
//构建霍夫曼树
public static treeNode createhuffmantree(List<treeNode> nodes){
while(nodes.size()>1){
Collections.sort(nodes);
treeNode leftNode=nodes.get(0);
treeNode rightNode=nodes.get(1);
treeNode parentNode=new treeNode(null,leftNode.value+rightNode.value);//非叶子节点只有权重,没有data
parentNode.left=leftNode;
parentNode.right=rightNode;
nodes.remove(0);
nodes.remove(0);
nodes.add(parentNode);
}
return nodes.get(0);
}
(4)将霍夫曼树转为霍夫曼编码,并将每个字符和它对应的霍夫曼编码存入Map中。
/*
* 功能描述:将霍夫曼树转为霍夫曼编码并存入Map中
* @param: node:传入节点
* @param: curcode:当前节点的路径
* @param: stringBuilder:用于字符串拼接
* @return void
*/
public static void getCodes(treeNode node,String curcode,StringBuilder stringBuilder){
StringBuilder stringBuilder2=new StringBuilder(stringBuilder);
stringBuilder2.append(curcode);
if(node!=null){
//如果node为空则不处理
//判断是否为叶子节点
if(node.data==null){
//说明为非叶子节点
getCodes(node.left,"0",stringBuilder2);
getCodes(node.right,"1",stringBuilder2);
}else{
//是叶子节点
huffmancodes.put(node.data,stringBuilder2.toString());
}
}
}
(5)遍历字符串对应的byte[]数组(即第1步得到的contentbytes),根据第4步得到的霍夫曼编码Map,查询到每个byte对应的霍夫曼编码,将其进行拼接,最终生成一长串二进制霍夫曼编码,但这串二进制编码并不能直接用于传输,要将其转换为byte[]形式。
/*
* 功能描述:将字符串对应的byte[]数组,根据霍夫曼编码Map,生成一长串二进制霍夫曼编码,并将其转换为byte[]
* @param: bytes 即contentbytes
* @param: huffmanCodes 每个字符的byte对应的映射表
* @return byte[] 拼接好的二进制霍夫曼编码转化为byte[]
*/
public static byte