赫夫曼压缩（萌新劝退）
13.5 赫夫曼编码
基本介绍：
-
赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，属于程序算法
-
赫夫曼编码是赫夫曼树在电讯通讯中的经典应用一致
-
赫夫曼编码广泛的应用与数据文件压缩，其 压缩率通常在20%~90%之间
-
赫夫曼是 可变字长编码(VLC)的一种。Huffman与1952年提出一种编码方式称之为 最佳编码
赫夫曼编码压缩思路例：
-
获取一个字符串
i like like like java do you like a java -
然后统计各个字母出现的次数
d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 (空格):9 -
按照上面字符出现的次数当作叶子节点权值构建一颗霍夫曼树
-
根据赫夫曼树（ 构建的赫夫曼树不一样，编码也可能不一样，因为可能存在两个相等的左右节点，所以赫夫曼树可能不一样，但是
wpl是一样的，都是最小的），给各个字符规定编码，向左的路径为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字符串对应的编码（赫夫曼编码是无损压缩）,通过赫夫曼长度变成 133，而使用AscII码出来的长度是359
(1) Node{data(存放数据), weight(权值), left 和 right}
(2) 得到 i like like like java do you like a java对应的byte[] 数组
(3) 编写一个方法，将准备构建赫夫曼树的Node 节点放到 List , 形式[Node[data=97,weight=5], Node[data=32,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创建对应的赫夫曼树
package huffmancode;
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[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
byte[] huffmanCodeBytes = huffmanZip(contentBytes);
System.out.println("压缩后的编码为"+Arrays.toString(huffmanCodeBytes));
System.out.println("长度为："+huffmanCodeBytes.length);
// 分布过程
/*
List<Node> nodes = getNode(contentBytes);
System.out.println(nodes);
Node huffmanTreeRoot = createHuffmanTree(nodes);
System.out.println("前序遍历");
huffmanTreeRoot.preOrder();
// 测试是否生成了对应的赫夫曼编码
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
System.out.println("~生成的赫夫曼编码表："+ huffmanCodes);
// 测试
huffmanCodeBytes = zip(contentBytes, huffmanCodes);
System.out.println("huffmanCodeBytes="+Arrays.toString(huffmanCodeBytes));
// 发送 HuffmanCodeBytes 数组
*/
}
// 使用一个方法，将前面的方法封装起来，便于我们的调用
/**
*
* @param bytes 原始的字符串对应的字节数组
* @return 是经过 赫夫曼编码 处理后的字节数组（压缩后的数组）
*/
private static byte[] huffmanZip(byte[] bytes){
List<Node> nodes = getNode(bytes);
// 根据 nodes 创建赫夫曼树
Node huffmanTreeRoot = createHuffmanTree(nodes);
// 根据赫夫曼树创建赫夫曼编码
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
// 根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
byte[] huffmanCodeBytes = zip(bytes,huffmanCodes);
return huffmanCodeBytes;
}
// 编写一个方法，将一个字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码，压缩后的byte[]数组
/**
*
* @param bytes 这是原始的字符串对应的 byte[]
* @param huffmanCodes 生成的赫夫曼编码 map
* @return 返回赫夫曼编码处理后的 byte[]
*/
private static byte[] zip(byte[] bytes, Map<Byte,String> huffmanCodes){
// 1. 利用 huffmanCodes 将 bytes 转成 赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
// 遍历 bytes 数组
for (byte b: bytes){
stringBuilder.append(huffmanCodes.get(b));
}
System.out.println(stringBuilder.toString());
// 将 "101010001011111110..."转成 byte[]
// 统计返回的 byte[] huffmanCodeBytes 长度
int len;
// 下面代码一句话搞定就是 len = (stringBuilder.length() + 7) / 8
if (stringBuilder.length() % 8 == 0){
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
// 创建一个存储压缩后的 byte数组
byte[] huffmanCodeBytes = new byte[len];
int index = 0; // 记录是第几个byte
for (int i = 0; i < stringBuilder.length(); i += 8){
// 因为是每8为对应一个byte
String strByte;
if (i + 8 > stringBuilder.length()){
// 不够8位了，那么有多少取多少
strByte = stringBuilder.substring(i);
} else {
strByte = stringBuilder.substring(i, i + 8);
}
// 将strByte转成一个 byte 放入到 huffmanCodeBytes
huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte,2);
index++;
}
return huffmanCodeBytes;
}
/**
*
* @param bytes 接受字节数组
* @return 返回是一个list形式
*/
private static List<Node> getNode(byte[] bytes){
// 创建一个ArrayList
ArrayList<Node> nodes = new ArrayList<>();
// 存储每个byte出现的次数 -> map
Map<Byte,Integer> counts = new HashMap<>();
for (byte b: bytes){
Integer count = counts.get(b);
if (count == null){
// 说明map还没有该字符数据
counts.put(b,1);
} else {
counts.put(b, count+1);
}
}
// 把每个键值对，转成一个node对象并加入弄得集合
// 遍历map
for (Map.Entry<Byte,Integer> entry:counts.entrySet()){
nodes.add(new Node(entry.getKey(),entry.getValue()));
}
return nodes;
}
// 创建赫夫曼树
private static Node createHuffmanTree(List<Node> nodes){
while(nodes.size() > 1){
// 排序（从小到大）
Collections.sort(nodes);
// 取出左右节点
Node leftNode = nodes.get(0);
Node rightNode = nodes.get(1);
Node parent = new Node(null,leftNode.weight + rightNode.weight);
parent.left = leftNode;
parent.right = rightNode;
// 删除左右节点
nodes.remove(leftNode);
nodes.remove(rightNode);
// 将新的节点加入
nodes.add(parent);
}
return nodes.get(0);
}
//前序遍历
private static void preOrder(Node root){
if (root != null){
root.preOrder();
}else{
System.out.println("赫夫曼树为空");
}
}
// 生成赫夫曼树对应的赫夫曼编码
//思路：
// 1. 将赫夫曼编码表存放在 Map<Byte,String>
static Map<Byte,String> huffmanCodes = new HashMap<Byte, String>();
// 2. 在生成赫夫曼编码表时，需要去拼接路径，定义一个 StringBuilder 存储某个叶子节点的路径
static StringBuilder stringBuilder = new StringBuilder();
// 为了方便，重载getCodes
private static Map<Byte,String> getCodes(Node root){
if (root == null){
return null;
}
// 处理root左子树
getCodes(root.left,"0",stringBuilder);
// 处理root右子树
getCodes(root.right, "1", stringBuilder);
return huffmanCodes;
}
/**
* 功能：将传入的node结点的所有叶子节点的赫夫曼编码得到，并放入到huffmanCodes
* @param node 传入的节点（默认跟结点开始）
* @param code 代表路径；左子节点代表0，右子节点表示1
* @param stringBuilder 用于拼接路径的
*/
private static void getCodes(Node node, String code, StringBuilder stringBuilder){
StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
// 将code加入到 stringBuilder2
stringBuilder2.append(code);
if (node != null){ // 如果 node == null 不处理
// 判断当前 node 是叶子节点还是非叶子节点
if (node.data == null){
// 非叶子节点，递归处理
// 向左递归
getCodes(node.left,"0",stringBuilder2);
// 向右递归
getCodes(node.right,"1",stringBuilder2);
} else {
// 说明是叶子节点
// 就表示找到了某个叶子节点
huffmanCodes.put(node.data,stringBuilder2.toString());
}
}
}
}
// 创建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.println(this);
if (this.left != null){
this.left.preOrder();
}
if (this.right != null){
this.right.preOrder();
}
}
}
浙公网安备 33010602011771号