哈夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式,哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法,该方法完全依据字符出现概率来构造异字头的平均长度最短的码字,有时称之为最佳编码,一般就叫做Huffman编码(有时也称为霍夫曼编码)。
package com.atguigu.huffmancode;
import java.util.*;
/**
* @author 南有嘉鱼
* @create 2021-11-23 8:44
*/
public class HuffmanCode {
//将霍夫曼编码表存放在 Map<Byte,String>
static Map<Byte, String> huffmanCodes = new HashMap<>();
//经过霍夫曼编码后,拼接所有叶子节点路径
static StringBuilder huffmanCodesStr = new StringBuilder();
public static void main(String[] args) {
// String content = "i like like like java do you like a java";
String content = "解压时,最后一个字节转成二进制时";
byte[] huffmanCodesBytes = huffmanZip(content);
byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);
System.out.println(new String(sourceBytes));
}
/**
* 完成对压缩数据的解码
* @param huffmanCodes 霍夫曼编码表map
* @param huffmanBytes 霍夫曼编码得到的数组
* @return 原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes,byte[] huffmanBytes){
//1. 先得到huffmanBytes对应的二进制字符串 10101000101111111100100010111111110...
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < huffmanBytes.length - 1; i++) {
stringBuilder.append(byteToBitStr(true,huffmanBytes[i]));
}
//!!!特别注意:由于最后一个byte转成二进制时,位数无法确定,所有需要特别处理最后一个byte
String lastByte = byteToBitStr(false,huffmanBytes[huffmanBytes.length - 1]);
if (lastByte.length() + stringBuilder.length() != huffmanCodesStr.length()) {
while (lastByte.length() + stringBuilder.length() < huffmanCodesStr.length()) {
stringBuilder.append(0);
}
}
stringBuilder.append(lastByte);
//2. 获取到霍夫曼编码的解码表,即把霍夫曼编码表进行反向调换
Map<String,Byte> map = new HashMap<>();
for (Map.Entry<Byte, String> entry : huffmanCodes.entrySet()) {
map.put(entry.getValue(),entry.getKey());
}
//3. 根据字符串按照指定的霍夫曼解码表进行解码
List<Byte> list = new ArrayList<>();
for (int i = 0;i < stringBuilder.length();){
int count = 1;
boolean flag = true;
Byte b = null;
while (flag){
String key = stringBuilder.substring(i,i + count);
b = map.get(key);
if (b == null){
count++;
} else {
flag = false;
}
}
list.add(b);
i += count;
}
byte[] b = new byte[list.size()];
for (int i = 0; i < b.length; i++) {
b[i] = list.get(i);
}
return b;
}
/**
* 将一个byte类型的数转换成该数二进制的8位补码形式
*
* @param flag 正数需要补高位,为true,反之亦然
* @param b 传入的byte
* @return b对应的二进制补码的字符串
*/
private static String byteToBitStr(boolean flag, byte b) {
int temp = b;
if (flag) {
//如果是正数,需要补高位
temp |= 256; //或运算
}
String str = Integer.toBinaryString(temp); //返回的是temp对应的二进制的补码
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
private static byte[] huffmanZip(String content) {
//将原始的字符串转换成对应的字节数组(即将原始字符串的每一个字符转换成对应的ANSI码)
byte[] contentBytes = content.getBytes();
//统计每一个字符出现的次数,得到List<Node>
List<Node> nodes = getNodes(contentBytes);
//创建对应的霍夫曼树
Node huffmanTreeRoot = createHuffmanTree(nodes);
//生成霍夫曼树对应的编码表
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
//进行霍夫曼压缩编码
byte[] huffmanCodesBytes = zip(contentBytes, huffmanCodes);
return huffmanCodesBytes;
}
/**
* 将原始字符串对应的byte[]数组,根据霍夫曼编码表进行编码,返回一个霍夫曼编码压缩后的byte[]
*
* @param bytes 原始的字符串对应的数组
* @param huffmanCodes 生成的霍夫曼编码表 map
* @return 返回霍夫曼编码处理后的byte[]
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
//1. 利用霍夫曼编码表HuffmanCodes 将bytes转成霍夫曼对应的字符串
for (byte b : bytes) {
huffmanCodesStr.append(huffmanCodes.get(b));
}
//2. 根据huffmanCodesStr.length()确定返回值byte[] huffmanCodeBytes的长度
int len = (huffmanCodesStr.length() + 7) / 8;
//3. 创建一个存储压缩后的byte数组,根据霍夫曼编码表进行编码
byte[] huffmanCodeBytes = new byte[len];
int index = 0; //记录是第几个byte
for (int i = 0; i < huffmanCodesStr.length(); i += 8) {
String strByte;
if (i + 8 > huffmanCodesStr.length()) { //截取最后剩余的二进制字符串
strByte = huffmanCodesStr.substring(i);
} else {
strByte = huffmanCodesStr.substring(i, i + 8); //左闭右开
}
//4. 将strByte先转换成int类型,再强转成byte,放入到huffmanCodeBytes
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
//重载,方便递归调用
private static Map<Byte, String> getCodes(Node root) {
if (root == null) {
return null;
}
//处理root的左子树
getCodes(root.left, "0", huffmanCodesStr);
//处理root的右子树
getCodes(root.right, "1", huffmanCodesStr);
return huffmanCodes;
}
/**
* 将传入的霍夫曼树root节点的所有叶子节点的霍夫曼编码得到,并放入到huffmanCodes集合
* @param node 传入霍夫曼树root节点
* @param code 路径:左子节点是0,右子节点是1
* @param stringBuilder 用于拼接路径
*/
private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
stringBuilder2.append(code);
if (node != null) { //如果node == null,不处理
if (node.data == null) { //判断是否为非叶子节点
//向左递归
getCodes(node.left, "0", stringBuilder2);
//向右递归
getCodes(node.right, "1", stringBuilder2);
} else { //说明是一个叶子节点,就表示找到某个叶子节点的最后
huffmanCodes.put(node.data, stringBuilder2.toString());
}
}
}
/**
* 创建霍夫曼树
* @param nodes 集合里的每一个Node保存了字符的ANSI值和权值(出现次数))
* @return 返回霍夫曼树的根节点
*/
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
Node leftNode = nodes.get(0);
Node rightNode = nodes.get(1);
//创建一颗新的二叉树,它的根节点没有data,只有权值weight
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);
}
/**
* 遍历原始字符串对应的byte[]数组,统计每一个字符出现的次数
* @param bytes
* @return 返回的list集合里的每一个Node保存了字符的ANSI值和权值(出现次数))
*/
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//遍历bytes,统计每一个byte出现的次数 ->map[key,value]
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对象,并加入到nodes集合
for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
//前序遍历
private static void preOrder(Node root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("霍夫曼树为空!");
}
}
}
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();
}
}
}
如有疑问,欢迎私信或者发邮件到2450836033@qq.com