赫夫曼树
基本介绍：
- 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(HuffmanTree), 还有的书翻译为霍夫曼树。
- 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
赫夫曼树几个重要概念和举例说明：
- 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。
- 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。
- 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
- WPL最小的就是赫夫曼树
构成赫夫曼树的步骤：
- 从小到大进行排序, 将每一个数据都看做一个节点 ， 每个节点就可以看成是一颗最简单的二叉树，该节点就为二叉树的根节点。
- 取出根节点权值最小的两颗二叉树。
- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和。
- 再将这颗新的二叉树，以根节点的权值大小在这组数据中再次排序， 不断重复 1-2-3-4的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树。
赫夫曼树创建思路图解：
代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class HuffmanTree {
public static void main(String[] args) {
int[] arr = { 13, 7, 8, 3, 29, 6, 1 };
//测试
Node root = createHuffmanTree(arr);
//进行前序遍历此二叉树，看是否与预期的相同
preOrder(root);
}
public static void preOrder(Node root) {
if(root!=null) {
root.preOrder();
}else {
System.out.println("赫夫曼树是空的，无法遍历");
}
}
// 创建赫夫曼树的方法,返回赫夫曼树的根节点
public static Node createHuffmanTree(int[] arr) {
// 1.遍历arr数组
// 2.将arr中每一个元素构成一个Node
// 3.将Node放入ArrayList中
List<Node> nodes = new ArrayList<Node>();
for (int value : arr) {
nodes.add(new Node(value));
}
while (nodes.size() > 1) {// 当集合中只剩下一个数据时，即构建完成
// 从小到大排序
Collections.sort(nodes);
// 取出权值最小的两颗二叉树（包括仅一个节点）
// 取出权值最小的二叉树（节点）
Node leftNode = nodes.get(0);
// 取出权值第二小的二叉树（节点）
Node rightNode = nodes.get(1);
// 用这两个二叉树构建一个新的二叉树
Node father = new Node(leftNode.val + rightNode.val);
father.left = leftNode;
father.right = rightNode;
// 从集合中删除掉刚处理的两颗二叉树
nodes.remove(leftNode);
nodes.remove(rightNode);
// 将新构建的father二叉树加入集合中
nodes.add(father);
}
//返回赫夫曼数的root节点
return nodes.get(0);
}
}
// 创建节点类
// 为了让Node对象支持排序Collections集合排序，则需让Node实现Comparable接口
class Node implements Comparable<Node> {
int val;// 节点权值
Node left;
Node right;
public Node(int val) {
this.val = val;
}
@Override
public String toString() {
return "Node [val=" + val + "]";
}
@Override
public int compareTo(Node o) {
// 表示从小到大进行排序
return this.val - o.val;
}
public void preOrder() {//前序遍历方法
System.out.println(this);
if(this.left!=null) {
this.left.preOrder();
}
if(this.right!=null) {
this.right.preOrder();
}
}
}
结果：
Node [val=67]
Node [val=29]
Node [val=38]
Node [val=15]
Node [val=7]
Node [val=8]
Node [val=23]
Node [val=10]
Node [val=4]
Node [val=1]
Node [val=3]
Node [val=6]
Node [val=13]
赫夫曼编码
基本介绍：
- 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法。
- 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
- 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间。
- 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码。
原理剖析：
-
通信领域中信息的处理方式1-定长编码：
-
通信领域中信息的处理方式2-变长编码：
-
通信领域中信息的处理方式3-赫夫曼编码：
注意： 这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是wpl 是一样的，都是最小的, 比如: 如果我们让每次生成的新的二叉树总是排在权值相同的二叉树的最后一个，则生成的二叉树为：
但是并不影响最终的压缩长度，也就是此哈弗曼树来编码后长度依然为133。
代码实现：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class HuffmanTreeCode {
public static void main(String[] args) {
String content = "i like like like java do you like a java";
System.out.println("原数组长度为：" + content.length());
byte[] ContentBytes = content.getBytes();
byte[] huffmanCodesBytes = huffmanZip(ContentBytes);
System.out.println("压缩后的结果为：" + Arrays.toString(huffmanCodesBytes));
System.out.println("压缩后的长度为：" + huffmanCodesBytes.length);
byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);
System.out.println("解压后的字符串为：");
System.out.println(new String(sourceBytes));
}
// 完成数据的解压
// 1.先将数组转换为赫夫曼编码对应的字符串
// 2.再转换为原本的字符串
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
// 先得到huffmanBytes对应的二进制字符串
StringBuilder stringBuilder = new StringBuilder();
// 将byte数组转换为二进制字符串
for (int i = 0; i < huffmanBytes.length; i++) {
boolean flag = (i == huffmanBytes.length - 1);// 判断是否为最后一个字节
stringBuilder.append(byteToBitString(!flag, huffmanBytes[i]));
}
// 将字符串按赫夫曼编码表进行解码
// 先得到反向的赫夫曼编码表
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<Byte>();
StringBuilder stringBuilder2 = new StringBuilder();
for (int i = 0; i < stringBuilder.length(); i++) {
stringBuilder2.append(stringBuilder.substring(i, i + 1));
Byte b = map.get(stringBuilder2.toString());
if (b != null) {
list.add(b);
stringBuilder2.delete(0, stringBuilder2.length());// 清空
}
}
byte[] bytes = new byte[list.size()];
for (int i = 0; i < list.size(); i++) {
bytes[i] = list.get(i);
}
return bytes;
}
/**
* 将一个byte转换为一个二进制字符串
*
* @param flag
* true则需要补高位，false则不需要补高位。即如果不是最后一个字节则都需要补高位，不管是正是负；若为最后一个字节则不用补高位
* @param b
* 传入的byte
* @return 返回b所对应的二进制字符串（补码）
*/
private static String byteToBitString(boolean flag, byte b) {
// 使用变量保存b
int temp = b;// 将b转换为int类型
// 如果是正数需要补高位
if (flag) {
temp |= 256;// 按位或运算 256 1 0000 0000 | 0000 0001 = 1 0000 0001
}
String str = Integer.toBinaryString(temp);// 返回的是temp对应的二进制补码
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
// 使用一个方法，将前面的方法封装起来方便调用
/**
*
* @param bytes
* 原始的字符串对应的字节数组
* @return 返回经过赫夫曼编码后的字节数组（压缩后的数组）
*/
private static byte[] huffmanZip(byte[] bytes) {
// 将bytes数组中的每一个元素转换为一个节点，存入List集合中
List<Node> nodes = getNodes(bytes);
// 根据这个集合来生成赫夫曼树，得到这个树的头结点
Node HuffmanTreeRoot = createHuffmanTree(nodes);
// 根据赫夫曼树头结点生成赫夫曼编码表
Map<Byte, String> huffmanCodes = getCodes(HuffmanTreeRoot);
// 根据赫夫曼编码表，将bytes数组最后转换为压缩后的字节数组
byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
// 返回这个数组
return huffmanCodeBytes;
}
// 编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
/**
*
* @param bytes
* 这时原始的字符串对应的 byte[]
* @param huffmanCodes
* 生成的赫夫曼编码map
* @return 返回赫夫曼编码处理后的 byte[] 举例： String content = "i like like like java do you
* like a java"; =》 byte[] contentBytes = content.getBytes(); 返回的是 字符串
* "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
* => 对应的 byte[] huffmanCodeBytes ，即 8位对应一个 byte,放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000(补码) => byte [推导 10101000=> 10101000 -
* 1 => 10100111(反码)=> 11011000= -88 ] huffmanCodeBytes[1] = -88
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
// 利用huffmanCodes将bytes数组转换为赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
// 将此字符串转换为byte[] huffmanCodeBytes并返回
// 先统计长度
int len;
len = (stringBuilder.length() + 7) / 8;
// 创建存储压缩后的byte数组
byte[] huffmanCodeBytes = new byte[len];
int index = 0;// 记录是第几个byte
for (int i = 0; i < stringBuilder.length(); i += 8) {
String strByte;
if (i + 8 > stringBuilder.length()) {// 当不够8位时
strByte = stringBuilder.substring(i);
} else {
strByte = stringBuilder.substring(i, i + 8);
}
// 将strByte转为byte并放入huffmanCodesByte数组中
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
// 为了方便调用，我们重载getCodes方法
private static Map<Byte, String> getCodes(Node root) {
if (root == null) {
System.out.println("哈弗曼树为空");
return null;
}
getCodes(root, "", stringBuilder);
return huffmanCodes;
}
// 生成赫夫曼树对应的赫夫曼编码
// 将赫夫曼编码表保存在Map<Byte,String>集合中
// 形式：32->01 97->100 100->11000......
static Map<Byte, String> huffmanCodes = new HashMap<Byte, String>();
// 因为需要拼接路径，所以需要定义一个StringBuilder存储某个叶子节点的路径
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的node节点的所有叶子节点的赫夫曼编码找到，并放入buffmanCodes集合中
*
* @param node
* 传入节点
* @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不处理
// 判断当前node是叶子节点还是非叶子节点
if (node.data == null) {// 非叶子节点
// 向左递归
getCodes(node.left, "0", stringBuilder2);
// 向右递归
getCodes(node.right, "1", stringBuilder2);
} else {// 说明是一个叶子节点
huffmanCodes.put(node.data, stringBuilder2.toString());
}
}
}
// 前序遍历
private static void preOrder(Node root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("赫夫曼树为空，无法遍历");
}
}
// 接收一个字符数组，将其转换为ArrayList并返回
private static List<Node> getNodes(byte[] bytes) {
// 创建一个ArrayList集合
List<Node> nodes = new ArrayList<Node>();
// 遍历bytes，将每个byte数据用->map[key,value]来保存
Map<Byte, Integer> counts = new HashMap<>();
for (Byte b : bytes) {
Integer count = counts.get(b);
if (count == null) {
counts.put(b, 1);
} else {
counts.put(b, count + 1);
}
}
// 遍历map，把每一个键值转换为Node对象并存入ArrayList集合中
for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
// 通过List创建赫夫曼树
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值，所以传null
Node father = new Node(null, leftNode.weight + rightNode.weight);
father.left = leftNode;
father.right = rightNode;
// 删除
nodes.remove(leftNode);
nodes.remove(rightNode);
// 添加新的数
nodes.add(father);
}
return nodes.get(0);
}
}
// 创建Node，带数据和权值
class Node implements Comparable<Node> {
Byte data;
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
super();
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();
}
}
}
结果：
原数组长度为：40
压缩后的结果为：[-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
压缩后的长度为：17
解压后的字符串为：
i like like like java do you like a java
下面我们可以对文件进行压缩和解压：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class HuffmanTreeCode {
public static void main(String[] args) {
//压缩文件
String srcFile1 = "E:\\Desktop/picture.jpg";
String dstFile1 = "E:\\Desktop/picture.zip";
zipFile(srcFile1, dstFile1);
System.out.println("压缩成功");
//解压文件
String zipFile2 = "E:\\Desktop/picture.zip";
String dstFile2 = "E:\\Desktop/picture2.jpg";
unZipFile(zipFile2, dstFile2);
System.out.println("解压成功");
}
// 编写一个方法，完成对压缩文件的解压
/**
*
* @param zipFile
* 准备解压的文件
* @param dstFile
* 将文件解压到哪个路径
*/
public static void unZipFile(String zipFile, String dstFile) {
// 定义文件输入流
InputStream is = null;
// 定义一个对象输入流
ObjectInputStream ois = null;
// 定义文件的输出流
OutputStream os = null;
try {
// 创建文件输入流
is = new FileInputStream(zipFile);
// 创建一个和 is关联的对象输入流
ois = new ObjectInputStream(is);
// 读取byte数组 huffmanBytes
byte[] huffmanBytes = (byte[]) ois.readObject();
// 读取赫夫曼编码表
Map<Byte, String> huffmanCodes = (Map<Byte, String>) ois.readObject();
// 解码
byte[] bytes = decode(huffmanCodes, huffmanBytes);
// 将bytes 数组写入到目标文件
os = new FileOutputStream(dstFile);
// 写数据到 dstFile 文件
os.write(bytes);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
} finally {
try {
os.close();
ois.close();
is.close();
} catch (Exception e2) {
// TODO: handle exception
System.out.println(e2.getMessage());
}
}
}
// 编写方法，将一个文件进行压缩
/**
*
* @param srcFile
* 你传入的希望压缩的文件的全路径
* @param dstFile
* 我们压缩后将压缩文件放到哪个目录
*/
public static void zipFile(String srcFile, String dstFile) {
// 创建输出流
OutputStream os = null;
ObjectOutputStream oos = null;
// 创建文件的输入流
FileInputStream is = null;
try {
// 创建文件的输入流
is = new FileInputStream(srcFile);
// 创建一个和源文件大小一样的byte[]
byte[] b = new byte[is.available()];
// 读取文件
is.read(b);
// 直接对源文件压缩
byte[] huffmanBytes = huffmanZip(b);
// 创建文件的输出流, 存放压缩文件
os = new FileOutputStream(dstFile);
// 创建一个和文件输出流关联的ObjectOutputStream
oos = new ObjectOutputStream(os);
// 把 赫夫曼编码后的字节数组写入压缩文件
oos.writeObject(huffmanBytes); // 我们是把
// 这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用
// 注意一定要把赫夫曼编码 写入压缩文件
oos.writeObject(huffmanCodes);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
} finally {
try {
is.close();
oos.close();
os.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
// 完成数据的解压
// 1.先将数组转换为赫夫曼编码对应的字符串
// 2.再转换为原本的字符串
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
// 先得到huffmanBytes对应的二进制字符串
StringBuilder stringBuilder = new StringBuilder();
// 将byte数组转换为二进制字符串
for (int i = 0; i < huffmanBytes.length; i++) {
boolean flag = (i == huffmanBytes.length - 1);// 判断是否为最后一个字节
stringBuilder.append(byteToBitString(!flag, huffmanBytes[i]));
}
// 将字符串按赫夫曼编码表进行解码
// 先得到反向的赫夫曼编码表
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<Byte>();
StringBuilder stringBuilder2 = new StringBuilder();
for (int i = 0; i < stringBuilder.length(); i++) {
stringBuilder2.append(stringBuilder.substring(i, i + 1));
Byte b = map.get(stringBuilder2.toString());
if (b != null) {
list.add(b);
stringBuilder2.delete(0, stringBuilder2.length());// 清空
}
}
byte[] bytes = new byte[list.size()];
for (int i = 0; i < list.size(); i++) {
bytes[i] = list.get(i);
}
return bytes;
}
/**
* 将一个byte转换为一个二进制字符串
*
* @param flag
* true则需要补高位，false则不需要补高位。即如果不是最后一个字节则都需要补高位，不管是正是负；若为最后一个字节则不用补高位
* @param b
* 传入的byte
* @return 返回b所对应的二进制字符串（补码）
*/
private static String byteToBitString(boolean flag, byte b) {
// 使用变量保存b
int temp = b;// 将b转换为int类型
// 如果是正数需要补高位
if (flag) {
temp |= 256;// 按位或运算 256 1 0000 0000 | 0000 0001 = 1 0000 0001
}
String str = Integer.toBinaryString(temp);// 返回的是temp对应的二进制补码
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
// 使用一个方法，将前面的方法封装起来方便调用
/**
*
* @param bytes
* 原始的字符串对应的字节数组
* @return 返回经过赫夫曼编码后的字节数组（压缩后的数组）
*/
private static byte[] huffmanZip(byte[] bytes) {
// 将bytes数组中的每一个元素转换为一个节点，存入List集合中
List<Node> nodes = getNodes(bytes);
// 根据这个集合来生成赫夫曼树，得到这个树的头结点
Node HuffmanTreeRoot = createHuffmanTree(nodes);
// 根据赫夫曼树头结点生成赫夫曼编码表
Map<Byte, String> huffmanCodes = getCodes(HuffmanTreeRoot);
// 根据赫夫曼编码表，将bytes数组最后转换为压缩后的字节数组
byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
// 返回这个数组
return huffmanCodeBytes;
}
// 编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
/**
*
* @param bytes
* 这时原始的字符串对应的 byte[]
* @param huffmanCodes
* 生成的赫夫曼编码map
* @return 返回赫夫曼编码处理后的 byte[] 举例： String content = "i like like like java do you
* like a java"; =》 byte[] contentBytes = content.getBytes(); 返回的是 字符串
* "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
* => 对应的 byte[] huffmanCodeBytes ，即 8位对应一个 byte,放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000(补码) => byte [推导 10101000=> 10101000 -
* 1 => 10100111(反码)=> 11011000= -88 ] huffmanCodeBytes[1] = -88
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
// 利用huffmanCodes将bytes数组转换为赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
// 将此字符串转换为byte[] huffmanCodeBytes并返回
// 先统计长度
int len;
len = (stringBuilder.length() + 7) / 8;
// 创建存储压缩后的byte数组
byte[] huffmanCodeBytes = new byte[len];
int index = 0;// 记录是第几个byte
for (int i = 0; i < stringBuilder.length(); i += 8) {
String strByte;
if (i + 8 > stringBuilder.length()) {// 当不够8位时
strByte = stringBuilder.substring(i);
} else {
strByte = stringBuilder.substring(i, i + 8);
}
// 将strByte转为byte并放入huffmanCodesByte数组中
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
// 为了方便调用，我们重载getCodes方法
private static Map<Byte, String> getCodes(Node root) {
if (root == null) {
System.out.println("哈弗曼树为空");
return null;
}
getCodes(root, "", stringBuilder);
return huffmanCodes;
}
// 生成赫夫曼树对应的赫夫曼编码
// 将赫夫曼编码表保存在Map<Byte,String>集合中
// 形式：32->01 97->100 100->11000......
static Map<Byte, String> huffmanCodes = new HashMap<Byte, String>();
// 因为需要拼接路径，所以需要定义一个StringBuilder存储某个叶子节点的路径
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的node节点的所有叶子节点的赫夫曼编码找到，并放入buffmanCodes集合中
*
* @param node
* 传入节点
* @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不处理
// 判断当前node是叶子节点还是非叶子节点
if (node.data == null) {// 非叶子节点
// 向左递归
getCodes(node.left, "0", stringBuilder2);
// 向右递归
getCodes(node.right, "1", stringBuilder2);
} else {// 说明是一个叶子节点
huffmanCodes.put(node.data, stringBuilder2.toString());
}
}
}
// 前序遍历
private static void preOrder(Node root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("赫夫曼树为空，无法遍历");
}
}
// 接收一个字符数组，将其转换为ArrayList并返回
private static List<Node> getNodes(byte[] bytes) {
// 创建一个ArrayList集合
List<Node> nodes = new ArrayList<Node>();
// 遍历bytes，将每个byte数据用->map[key,value]来保存
Map<Byte, Integer> counts = new HashMap<>();
for (Byte b : bytes) {
Integer count = counts.get(b);
if (count == null) {
counts.put(b, 1);
} else {
counts.put(b, count + 1);
}
}
// 遍历map，把每一个键值转换为Node对象并存入ArrayList集合中
for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
// 通过List创建赫夫曼树
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值，所以传null
Node father = new Node(null, leftNode.weight + rightNode.weight);
father.left = leftNode;
father.right = rightNode;
// 删除
nodes.remove(leftNode);
nodes.remove(rightNode);
// 添加新的数
nodes.add(father);
}
return nodes.get(0);
}
}
// 创建Node，带数据和权值
class Node implements Comparable<Node> {
Byte data;
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
super();
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();
}
}
}
可以看出来原图片（picture.jpg）被压缩后再解压为picture2.jpg文件，没有任何损失，由此可见这是一种无损压缩。
扫一扫
1649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
