赫夫曼树（哈夫曼树、霍夫曼树，最优二叉树）
赫夫曼树的实现及编码
- 一、赫夫曼树简介
- 1、简介
- 2、相关定义
- 二、赫夫曼树算法
- 1、算法思路
- 2、代码实现
- 三、赫夫曼树编码
- 1、基本介绍
- 2、实现原理：
- 2、代码实现
- 2.1、赫夫曼编码及解码的详细代码（带注释）
一、赫夫曼树简介
1、简介
1）给定n个权值（节点的值）作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为 赫夫曼树（哈夫曼树、霍夫曼树，最优二叉树）。
2）赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近
2、相关定义
1、路径：从一个节点往下可以到达子节点的之间的通路；
2、路径长度：通路中分支的数目。若规定跟节点所在的层数为1，则从根节点到第L层节点的路径长度为L-1；
3、节点的权：给树中的节点赋予一个有着某种含义的值；
4、节点的带权路径：从根结点到该结点之间的路径长度与该结点的权的乘积
5、WPL(weighted path length)树的带权路径长度：规定为所有叶子节点的带权路径长度之和。 权值越大的结点离根结点越近的二叉树才是最优二叉树。
WPL最小的树就是赫夫曼树：
二、赫夫曼树算法
1、算法思路
将数列 arr={12,3,5,8,34}，转成一颗赫夫曼树，步骤如下：
1、从小到大对数组进行排序，将每个数值存入 ArrayList 链表，每个数值都是一个节点，每个节点可以看成一个最简单的二叉树。
2、从 ArrayList 取出根节点权值最小的两颗二叉树，组成一颗新的二叉树，该新的二叉树的根节点的权值就是前两颗二叉树根节点权值的和。
3、然后从 ArrayList 中将前两颗二叉树根节点remove，再把新的二叉树的根节点的权值放入 ArrayList 中，然后再次排序。
4、不断重复上述步骤，直到 ArrayList 中只剩下 赫夫曼树的根节点时退出循环，这样就可以得到一棵赫夫曼树了。
2、代码实现
import java.util.ArrayList;
import java.util.Collections;
/**
* 哈夫曼树：最优二叉树
*/
public class HuffManTree {
public static void main(String[] args) {
int[] arr = {12,3,5,8,34};
//生成赫夫曼树
Node huffManTree = createHuffManTree(arr);
//前序遍历赫夫曼树
preOrder(huffManTree);
}
//创建赫夫曼树的方法
public static Node createHuffManTree(int[] arr) {
//遍历arr数组，将arr的每个元素构建成一个NOde,将Node放入ArrayList;
ArrayList<Node> nodes = new ArrayList<>();
for (int value : arr) {
nodes.add(new Node(value));
}
//循环，直到ArrayList只剩一个节点时结束
while (nodes.size() > 1) {
//从大到小排序
Collections.sort(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;
//从ArrayList 删除处理过的节点
nodes.remove(leftNode);
nodes.remove(rightNode);
//将父节点加入到ArrayList
nodes.add(parent);
}
//最后返回赫夫曼树的头就可以了
return nodes.get(0);
}
//编写一个前序遍历的方法
public static void preOrder(Node root){
if(root!=null){
root.preOrder();
}else {
System.out.println("空树，无法遍历");
}
}
}
/**
* 创建节点类
* 为了让NOde对象支持排序COllectins 集合排序
* 让Node 实现Comparable 接口
*/
class Node implements Comparable<Node> {
int value;//节点权值
Node left;//左子节点
Node right;//右子节点
//前序遍历
public void preOrder(){
System.out.println(this);
if(this.left!=null){
this.left.preOrder();
}
if(this.right!=null){
this.right.preOrder();
}
}
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;
}
}
三、赫夫曼树编码
1、基本介绍
- 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法 2) 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
- 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%~90%之间
- 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码
2、实现原理：
1)String str=“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) 按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值
步骤: 构成赫夫曼树的步骤:
- 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树
2)取出根节点权值最小的两颗二叉树- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
- 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理， 就得到一颗赫夫曼树
- 根据赫夫曼树，给各个字符,规定编码 (前缀编码)， 向左的路径为 0 向右的路径为 1 ， 编码 如下:
o: 1000
a : 110
l: 001 - 按照上面的赫夫曼编码，我们的"i like like like java do you like a java" 意这里我们使用的无损压缩) 10101001101111011110100110111101111010011011110111101000011000011100110011110000110 01111000100100100110111101111011100100001100001110 通过赫夫曼编码处理 长度为 133 6) 长度为 : 133
说明:
原来长度是 359 , 压缩了 (359-133) / 359 = 62.9%
此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性 赫夫曼编码是无损处理方案
2、代码实现
2.1、赫夫曼编码及解码的详细代码（带注释）
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.*;
/**
* 赫夫曼编码
*/
public class HuffManCode {
public static void main(String[] args) {
String s = "i like like like java do you like a java";
byte[] bytes = s.getBytes();
byte[] huffManCodesBytes = huffManZip(bytes);
System.out.println("压缩后的结果是： " + Arrays.toString(huffManCodesBytes) + ",长度是：" + huffManCodesBytes.length);
byte[] decode = decode(huffManCodes, huffManCodesBytes);
System.out.println("解压缩之后的原字符串：" + new String(decode));
}
/**
* 功能：封装测试的方法，方便调用
*
* @param bytes 原始字符串的数组
* @return 返回的是经过赫夫曼编码处理后的字节数组，可以理解成压缩后的数组
*/
private static byte[] huffManZip(byte[] bytes) {
//将字节数组转换成list
List<HuffManCodeNode> listCode = getCode(bytes);
//生成赫夫曼树
HuffManCodeNode huffManTree = createHuffManTree(listCode);
//生成赫夫曼编码
getCode(huffManTree);
//测试赫夫曼编码转数组
for (Map.Entry<Byte, String> entry : huffManCodes.entrySet()) {
}
byte[] zip = zip(bytes, huffManCodes);
return zip;
}
/**
* 功能：生成赫夫曼编码
*/
private static List<HuffManCodeNode> getCode(byte[] bytes) {
//创建ArrayList 集合存放字符编码和字符编码个数
ArrayList<HuffManCodeNode> nodes = new ArrayList<HuffManCodeNode>();
//创建map集合存放字符和对应字符出现的次数
Map<Byte, Integer> counts = new HashMap<Byte, Integer>();
//遍历字节数组，统计每个字符出现的次数,放入到Map集合中
for (byte b : bytes) {
Integer count = counts.get(b);
if (count == null) {
counts.put(b, 1);
} else {
counts.put(b, count + 1);
}
}
//遍历Map，把每个键值对转换成一个HuffManCodeNode对象，并加入nodes集合
for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
nodes.add(new HuffManCodeNode(entry.getKey(), entry.getValue()));
}
return nodes;
}
/**
* 功能：创建赫夫曼树
*/
public static HuffManCodeNode createHuffManTree(List<HuffManCodeNode> nodes) {
while (nodes.size() > 1) {
//先进行排序
Collections.sort(nodes);
//获取两个最小二叉树组成新的二叉树的左右子节点，两个的权值作为父节点的权值
HuffManCodeNode leftNode = nodes.get(0);
HuffManCodeNode rightNode = nodes.get(1);
//新的二叉树的父节点没有data值。
HuffManCodeNode parentNode = new HuffManCodeNode(null, leftNode.weigth + rightNode.weigth);
//父节点的左右子树
parentNode.left = leftNode;
parentNode.rigth = rightNode;
//从ArrayList移除前两个二叉树，然后把新二叉树的节点放入ArrayList中
nodes.remove(leftNode);
nodes.remove(rightNode);
nodes.add(parentNode);
}
return nodes.get(0);
}
/**
* 功能：前序遍历
*/
public static void preOrder(HuffManCodeNode root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("空树，无法遍历！");
}
}
/**
* 功能：生成赫夫曼树对应的赫夫曼编码，将赫夫曼编码表存放在map中
* =01 a=100 d=11000 u=11001 e=1110 v=11011 i=101 y=11010 j=0010 k=1111 l=000 o=0011
*/
static Map<Byte, String> huffManCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
//为了方便调用，重载
public static Map<Byte, String> getCode(HuffManCodeNode root) {
if (root == null) {
return null;
}
getCode(root.left, "0", stringBuilder);
getCode(root.rigth, "1", stringBuilder);
return huffManCodes;
}
/**
* 功能：将传入的root的节点的所有叶子节点的赫夫曼编码得到，并放入到huffManCodes;
*
* @param root 传入的节点
* @param code 路径：左子节点 0；右子节点 1；
* @param stringBuilder 拼接得到的赫夫曼编码
* @return
*/
public static void getCode(HuffManCodeNode root, String code, StringBuilder stringBuilder) {
StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
//将code 放入到stringBuilder2
stringBuilder2.append(code);
//root 为空 不处理
if (root != null) {
//判断该节点是叶子节点还是非叶子节点
if (root.data == null) {//非叶子节点
//向左递归
getCode(root.left, "0", stringBuilder2);
//向右递归
getCode(root.rigth, "1", stringBuilder2);
} else {//说明是个叶子节点
huffManCodes.put(root.data, stringBuilder2.toString());
}
}
}
/**
* 功能：编写一个方法，将字符串对应的byte[] 数组，通过生成的 赫夫曼编码表，返回赫夫曼编码压缩后的byte[]
* /将"10101000101111111100100010111111110010001011111111001001010011
* 01110001110000011011101000111100101000 101111111100110001001010011011100"
* 转成byte
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffManCode) {
StringBuilder stringBuilder = new StringBuilder();
//从map集合中获取赫夫曼编码进行拼接
for (byte b : bytes) {
stringBuilder.append(huffManCode.get(b));
}
System.out.println("测试 stringBuilder~~~=" + stringBuilder.toString());
//一个byte 相当于8个字节，计算stringBuilder与8取余
int len = 0;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
//创建byte[] 存储压缩后的byte[]
byte[] resBytes = new byte[len];
int index = 0;
//遍历赫夫曼编码
for (int i = 0; i < stringBuilder.length(); i += 8) {
String str;
//如果剩余位数不够8位，直接截取剩余的所有位数，
if (i + 8 > stringBuilder.length()) {
str = stringBuilder.substring(i);
} else {//如果剩余位数大于8位，则截取8位
str = stringBuilder.substring(i, i + 8);
}
//将截取到的编码 转换成byte
resBytes[index] = (byte) Integer.parseInt(str, 2);
index++;
}
return resBytes;
}
/**
* 功能：完成数据的解压
* 思路
* 1. 将 huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
* 重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."
* 2. 赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码 =》 "i like like like java do you like a java"
*/
/**
* @param huffManCodes 赫夫曼编码表 map
* @param huffManBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
**/
private static byte[] decode(Map<Byte, String> huffManCodes, byte[] huffManBytes) {
//先得到huffManBytes 对应的二进制的字符串，形式1010100010111·····
StringBuilder stringBuilder = new StringBuilder();
//将bytes数组转成二进制的字符串
for (int i = 0; i < huffManBytes.length; i++) {
byte b = huffManBytes[i];
//判断是不是最后一个字节
boolean flag = (i == huffManBytes.length - 1);
stringBuilder.append(byteToBitString(!flag, b));
}
System.out.println(stringBuilder.toString());
//把字符串安装指定的赫夫曼编码进行解码
// 把赫夫曼编码表进行调换，因为反向查询 a->100 100->a
Map<String, Byte> map = new HashMap<String, Byte>();
for (Map.Entry<Byte, String> entry : huffManCodes.entrySet()) {
map.put(entry.getValue(), entry.getKey());
}
//创建要给集合，存放 byte
List<Byte> list = new ArrayList<>();
for (int i = 0; i < stringBuilder.length(); ) {
int count = 1;
boolean flag = true;
Byte b = null;
while (flag) {
//i 不动，count移动，指定匹配到一个字符
String key = stringBuilder.substring(i, i + count);
b = map.get(key);
//匹配不到，count++;
if (b == null) {
count++;
} else {//匹配到
flag = false;
}
}
list.add(b);
//i 直接移动到 count
i += count;
}
//当 for 循环结束后，我们 list 中就存放了所有的字符
// 把 list 中的数据放入到 byte[] 并返回
byte[] resbyte = new byte[list.size()];
for (int i = 0; i < resbyte.length; i++) {
resbyte[i] = list.get(i);
}
return resbyte;
}
/**
* 功能：将一个byte 转成二进制字符串
*
* @param b 需要转换的byte
* @param flag 标志是否需要补高位如果是 true ，表示需要补高位，如果是 false 表示不补, 如果是最后一 个字节，无需补高位
* @return
*/
private static String byteToBitString(boolean flag, byte b) {
int tmp = b;
//如果是正数，需要补齐高位
if (flag) {
//按位与 256 1 0000 000 | 0000 0001 => 1 0000 0001
tmp |= 256;
}
String str = Integer.toBinaryString(tmp);
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
」
}
//创建Node,带数据和权值
class HuffManCodeNode implements Comparable<HuffManCodeNode> {
Byte data;//存放数据本身
int weigth;//权值,表示字符出现的次数
HuffManCodeNode left;
HuffManCodeNode rigth;
public HuffManCodeNode(Byte data, int weigth) {
this.data = data;
this.weigth = weigth;
}
@Override
public int compareTo(HuffManCodeNode o) {
return this.weigth - o.weigth;
}
@Override
public String toString() {
return "{HuffManCodeNode data=" + data + ", weigth=" + weigth + '}';
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.rigth != null) {
this.rigth.preOrder();
}
}
}
初学数据结构和算法，有不足的地方希望大家多多指出～～一起学习进步！！