赫夫曼编码
赫夫曼编码也称哈弗曼编码,是一种编码方式,属于一种程序算法,是哈夫曼树在通信中的经典应用之一。赫夫曼编码广泛地应用于数据文件压缩,其压缩率通常在 20%~90% ,是可变字长编码的一种。
赫夫曼编码实例:
(1)传输的字符串 i like like like java do you like a java
(2)统计字符使用频次: d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 空格:9
(3)按照字符出现的频数作为权值构建一棵赫夫曼树
步骤:
1)将数据从小到大依次排序,每个数据是一个节点,每个节点看成一棵最简单的二叉树;
2)取出节点权值最小的两棵二叉树;
3)组成一棵新的二叉树,该新的二叉树的根节点的权值是前面两棵二叉树根节点权值的和;
4)再将这棵新的二叉树,以根节点的权值大小再次排序,不断重复 1~4 的步骤,直到数列中所有的数据都被处理,就得到了一棵赫夫曼树。
(4)根据赫夫曼树,给各个字符规定编码(前缀编码),向左的路径为0,向右的路径为1,则对应的编码如下:
(5)按照上面的赫夫曼编码, 字符串 “i like like like java do you like a java” 对应的赫夫曼编码为:
(6)长度:133,原来的长度为359,压缩了(320-133)/320 = 58.44%,而且此编码满足前缀编码,即字符的编码不能是其他字符编码的前缀,不会造成匹配的多义性。
注意:赫夫曼编码是无损压缩,赫夫曼树根据排序方法不同对应的赫夫曼编码可能不同,但是对应的 wpl 是相同的,都是最小的,其赫夫曼编码的长度也是一样的。
功能:根据赫夫曼树压缩数据的原理,创建 “ i like like like java do you like a java” 对应的赫夫曼树。
思路:
(1)创建Node{ data(存放字符),weight(权值,字符频次),left,right };
(2)得到对应的byte[ ] 数组;
(3)编写一个方法,将准备构建赫夫曼树的节点放到 List,形式 { Node[data= 'a', weight = 5] , Node[data= ' ', weight = 9] , ......},体现d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 空格:9;
(4)可以通过 List 创建对应的赫夫曼树;
(5)根据赫夫曼树给各个字符进行编码;
(6)使用赫夫曼编码生产赫夫曼编码数据。
代码实现:
package heffmancode;
import java.util.*;
public class HuffmanCode {
public static void main(String[] args) {
String content = "i like like like java do you like a java";
byte[] huffumanCodeBytes = huffumanZip(content);
System.out.println("huffumanCodeBytes = " + Arrays.toString(huffumanCodeBytes) + "长度为:" + huffumanCodeBytes.length);//17个byte
//压缩率 (40-17)/40 = 57.5%,因为添加了 133 % 8 = 3位
}
//!!!使用一个方法将前面的方法封装起来 便于调用 !!!
//str: 原始字符串, 返回对应的压缩 byte[ ] 数组
private static byte[] huffumanZip(String content){
byte[] contentBytes = content.getBytes();//得到对应的byte[ ] 数组;
//System.out.println(contentBytes.length);
List<Node> nodes = getNodes(contentBytes);//将准备构建赫夫曼树的节点放到 nodes
//System.out.println("nodes = " + nodes);
Node huffmanTreeRoot = creatHuffmanTree(nodes);//通过 nodes 创建对应的赫夫曼树
//huffmanTreeRoot.preOrder();//前序遍历
//getCodes(huffmanTreeRoot,"",stringBuilder);
//System.out.println("生成的赫夫曼编码表:" + hufumanCodes);
//重载更简单
Map<Byte, String> huffumanCodes1 = getCodes(huffmanTreeRoot);
//System.out.println("生成的赫夫曼编码表:" + huffumanCodes1);
byte[] huffumanCodeBytes = zip(contentBytes,huffumanCodes1);
//System.out.println("huffumanCodeBytes = " + Arrays.toString(huffumanCodeBytes));//17个byte
//压缩率 (40-17)/40 = 57.5%
return huffumanCodeBytes;
}
private static List<Node> getNodes(byte[] bytes){
//创建List存储节点信息
List<Node> nodes = new ArrayList<>();
//遍历bytes 统计每一个字符出现的次数
Map<Byte,Integer> map = new HashMap<>();
for (int i = 0; i < bytes.length; i++) {
map.put(bytes[i], map.getOrDefault(bytes[i],0) + 1);
}
//System.out.println(map.toString());
//把每个键值对转成一个Node对象,并加入到nodes集合
for (Map.Entry<Byte,Integer> entry: map.entrySet()){
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
//System.out.println(nodes.toString());
return nodes;
}
//通过 list 创建对应的赫夫曼树
private static Node creatHuffmanTree(List<Node> nodes){
while (nodes.size() > 1) {
Collections.sort(nodes);//paix
Node leftNode = nodes.get(0);
Node rightNode = nodes.get(1);
Node parent = new Node(null,rightNode.weight + leftNode.weight);//根节点没有data,只有权值weight
parent.left = leftNode;
parent.right = rightNode;
nodes.remove(leftNode);
nodes.remove(rightNode);
nodes.add(parent);
}
return nodes.get(0);
}
//根据赫夫曼树生成对应的赫夫曼编码
//思路:
//1.将赫夫曼编码表存放在 Map<Byte, String>,如:[32,"01"]
static Map<Byte, String> huffumanCodes = new HashMap<>();
//2.在生成赫夫曼编码表时,需要去拼接路径,所以定义一个 StringBuilder 存储某个叶子节点的路径
static StringBuilder stringBuilder = new StringBuilder();
//将传入的 node 节点的所有叶子节点的赫夫曼编码得到,并放入到 hufumanCodes 集合
//node: 传入节点 code: 路径,左子节点是0 右子节点是1
private static void getCodes(Node node, String code, StringBuilder stringBuilder){
StringBuilder stringBuilder1 = new StringBuilder(stringBuilder);
//将code加入到stringBuilder1
stringBuilder1.append(code);
if (node != null){//node == null 不处理
//判断当前node是叶子节点 还是非叶子节点
if (node.data == null){
//非叶子节点 向左递归再向右递归
getCodes(node.left,"0",stringBuilder1);
getCodes(node.right,"1",stringBuilder1);
}else {
//找到叶子节点 则向 hufumanCodes 存储对应信息
huffumanCodes.put(node.data, stringBuilder1.toString());
}
}
}
//重载更简洁 赫夫曼树生成对应的赫夫曼编码
private static Map<Byte,String> getCodes(Node root){
if (root == null)
return null;
//处理左子树
getCodes(root.left,"0",stringBuilder);
//处理右子树
getCodes(root.right,"1",stringBuilder);
return huffumanCodes;
}
//编写一个方法,将一个字符串对应的byte[ ] 数组,通过生成的赫夫曼编码表,返回一个赫夫曼编码压缩后的byte[ ]
//bytes: 字符串对应的原始数组 hufumanCodes: 生成的赫夫曼编码表 返回赫夫曼编码表处理后的byte[ ]
//返回的是对应的byte[] huffumanCodeBytes, 即 8 位对应一个byte,放入到 huffumanCodeBytes
//huffumanCodeBytes[0] = 10101000(补码)变反码 10101000 - 1 = 10100111 ==> 11011000 = -88
//huffumanCodeBytes[0] = -88
private static byte[] zip(byte[] bytes, Map<Byte,String> huffumanCodes){
//1. 利用 huffumanCodes 将 bytes 转成 赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b: bytes){
stringBuilder.append(huffumanCodes.get(b));
}
//将“1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100”转换成bytes
//统计返回的 byte[ ] huffumanCodeBytes 长度
//一句话 int len = (stringBuilder.length() + 7) / 8;
int len;
if (stringBuilder.length() % 8 ==0){
len = stringBuilder.length() / 8;
}else {
len = stringBuilder.length() / 8 + 1;
}
//创建存储压缩的 byte 数组
byte[] huffumanCodeBytes = new byte[len];
int index = 0;
for (int i = 0; i < stringBuilder.length(); i += 8){
String strByte;
if (i + 8 > stringBuilder.length()){
strByte = stringBuilder.substring(i);
}else{
strByte = stringBuilder.substring(i,i+8);
}
//将strByte 转成一个 byte 放入到 huffumanCodeBytes
huffumanCodeBytes[index] = (byte) Integer.parseInt(strByte,2);
index++;
}
return huffumanCodeBytes;
}
}
//创建Node,带入数据和权值
class Node implements Comparable<Node>{
Byte data;//存放数据本身,比如 'a' ==> 97, ' ' ==> 32
int weight;//权值,表示字符出现的次数
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
//前序遍历
public void preOrder(){
System.out.printf(this + " ");
if (this.left != null) this.left.preOrder();
if (this.right != null) this.right.preOrder();
}
}