基本介绍
- 赫夫曼编码也翻译为_哈夫曼编码(HuffmanCoding)，又称霍夫曼编码，是一种编码方式,属于一种程序算法
- 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
- 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%~90%之间
- 赫夫曼码是可变字长编码(VLC)的一种。Huffman于 1952年提出-种编码方法，称之为最佳编码
原理剖析
按照字母出现的次数，进行排序，构建出一颗WPL最小的赫夫曼树，根据赫夫曼树，给各个字符规定编码，向左的路径为0向右的路径为1
得出编码如下：
0: 1000 u: 10010 d: 100110 y: 10011 i: 101 a: 110 k: 1110 e: 1111 j: 0000 v: 0001 I: 001 : 01
按照上面的赫夫曼编码，我们的"ilike like like javapdo you like a java"字符串对应的编码为(注意这里我们使用的无损压缩)
10101001101111011110100110111101111010011011110111101000011000011100110011110000110011110001001001001101111011110111001000011100001110通过赫夫曼编码处理长度为133
说明:
原来长度是359,压缩了(359-133)/359=62.9%
此编码满足前缀编码,即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性
注意,这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全于样，但是wpl是一样的，都是最小的,比如:如果我们让每次生成的新的二叉树总是排在权值相同的二叉树的最后一个，则生成的二叉树有可能不同
功能:根据赫夫曼编码压缩数据的原理， 需要创建"1 like like like java do you like a java"对应的赫夫曼树
数据压缩
思路:
(1) Node { data (存放数据)，weight (权值)，left 和right }
(2)得到"i like like like java do you like a java”对应的byte[]数组
(3)编写-一个方法，将准备构建赫夫曼树的Node节点放到List ,形式[Node[date='7 ,weight = 5],
Node[]date=32,weight = …体现d:1 y:1u:1j:2 v:2 o:2 l:4 k:4 e:4i:5 a:5 :9
(4)可以通过List创建对应的赫夫曼树
数据解压
就是数据压缩的反向操作
public class HuffmanCode {
public static void main(String[] args) {
//测试压缩文件
// String srcFile = "E:\\aa.png";
// String dstFile = "E:\\dst.zip";
// zipFile(srcFile, dstFile);
// System.out.println("压缩文件成功");
//测试解压文件
String zipFile = "E:\\dst.zip";
String dstFile = "D:\\aa.png";
unZipFile(zipFile, dstFile);
System.out.println("解压文件成功");
// String content = "i like like like java do you like a java";
// //将字符串转成byte数组
// byte[] contentBytes = content.getBytes();
// //赫夫曼编码进行压缩
// byte[] huffmanCodeBytes = huffmanZip(contentBytes);
// System.out.println("压缩后的结果="+Arrays.toString(huffmanCodeBytes));
//
// byte[] sourceBytes = decode(huffmanCodes, huffmanCodeBytes);
// System.out.println("原来的字符串："+new String(sourceBytes));
}
/**
* 编写一个方法，完成对压缩文件的解压
* @param zipFile 准备解压的文件
* @param dstFile 解压到哪里
*/
public static void unZipFile(String zipFile,String dstFile) {
//创建文件输入流
FileInputStream is = null;
//创建一个对象输入流
ObjectInputStream ois = null;
//创建文件输出流
FileOutputStream 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 e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
}
}
//编写一个方法，将一个文件进行压缩
public static void zipFile(String srcFile,String dstFile) {
//创建一个文件的输入流
FileInputStream is = null;
//创建输出流
FileOutputStream os = null;
ObjectOutputStream oos = 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();
os.close();
oos.close();
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println(e.getMessage());
}
}
}
//===========数据的解压=========================================
//完成数据的解压
//思路
//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 huffBytes 赫夫曼编码得到的字节数组
* @return 就是原来字符串对应的数组
*/
private static byte[] decode(Map<Byte,String> huffmanCodes,byte[] huffmanBytes) {
//先得到huffmanBytes 对应的二进制的字符串，形式1010100010111...
StringBuilder stringBuilder = new StringBuilder();
//将byte数组转成二进制的字符串
for (int i = 0; i < huffmanBytes.length; i++) {
byte b = huffmanBytes[i];
//判断是不是最后一个字节
boolean flag = (i == huffmanBytes.length -1);
stringBuilder.append(byToBitString(!flag, b));
}
//把字符串按照指定的赫夫曼编码进行解码
//把赫夫曼编码表进行调换，因为反向查询 a->100 100->a
HashMap<String, Byte> map = new HashMap<String, Byte>();
for (Map.Entry<Byte,String> entry: huffmanCodes.entrySet()) {
map.put(entry.getValue(), entry.getKey());
}
//创建一个集合，存放byte
ArrayList<Byte> list = new ArrayList<>();
//i可以理解成就是索引，扫描stringBuilder
for (int i = 0; i < stringBuilder.length();) {
int count = 1;//小的计数器
boolean flag = true;
Byte b = null;
while (flag) {
//递增 取出一个"1"或"0"
String key = stringBuilder.substring(i,i+count);//i不动，让count移动，直到匹配到一个字符
b = map.get(key);
if (b == null) {//说明没有匹配到
count++;
}else {
//匹配到
flag = false;
}
}
list.add(b);
i += count;//让i直接移动count位
}
//当for循环结束后，我们list中就存放了所有的字符
//把list中的数据放入byte[]并返回
byte[] b = new byte[list.size()];
for (int i = 0; i < b.length; i++) {
b[i] = list.get(i);
}
return b;
}
/**
* 将一个byte转成一个二进制的字符串
* @param flag flag标志是否需要补高位如果是true.表示需要补高位，如果是false表示不补
* @param b 传入的byte 是该b对应的二进制的字符串，(注意是按补码返回)
* @return
*/
private static String byToBitString(Boolean flag,byte b) {
//使用变量保存b
int temp = b;//将b转成int
//如果是正数我们还存在补高位
if (flag) {
temp |= 256;//按位与 256 1 0000 0000
}
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) {
//1、将bytes中的字符统计放入集合中
List<Node> nodes = getNodes(bytes);
//2、根据nodes构建赫夫曼树
Node HuffmanTree = createHuffmanTree(nodes);
//3、通过构建赫夫曼树生成的赫夫曼编码表
Map<Byte, String> huffmanCodes = getCodes(HuffmanTree);
//4、根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
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) {
//利用huffmanCodes将bytes转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
//遍历bytes数组
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
//统计byte[] huffmanCodeBytes长度
int len;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
}else {
len = stringBuilder.length() / 8 + 1;
}
//创建一个存储压缩后的byte数组
byte[] huffmanCodeBytes = new byte[len];
int index = 0;
for (int i = 0; i < stringBuilder.length(); i+=8) {//因为是每8位对应一个byte，所以步长为8
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;
}
//生成赫夫曼树对应的赫夫曼编码
//思路:
//1.将赫夫曼编码表存放在Map<Byte,String>形式
// 32->01 97->100 100- >11000等等[形式]
static Map<Byte, String> huffmanCodes = new HashMap<Byte, String>();
//2.在生成赫夫曼编码表示，需要去拼接路径，定义一个StringBuilder存储某个叶子结点的路径
static StringBuilder stringBuilder = new StringBuilder();
//为了方便，我们重载getCode
private static Map<Byte,String> getCodes(Node root) {
if (root == null) {
return null;
}
//处理root的左子树
geteCodes(root.left, "0", stringBuilder);
//处理root的右子树
geteCodes(root.right, "1", stringBuilder);
return huffmanCodes;
}
/**
* 功能：将传入的node节点的所有叶子节点的赫夫曼编码得到，并放入到huffmanCodes集合
* @param node 传入节点
* @param code 路径：左子节点是0，右子节点是1
* @param stringBuilder 用于拼接路径
*/
private static void geteCodes(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) {
//递归处理
//向左递归
geteCodes(node.left, "0", stringBuilder2);
geteCodes(node.right, "1", stringBuilder2);
}else {//说明是一个叶子节点
//就表示找到某个叶子节点的最后
huffmanCodes.put(node.data, stringBuilder2.toString());
}
}
}
private static void preOrader(Node root) {
if (root != null) {
root.preOrader();
}else {
System.out.println("二叉树为空，不能遍历");
}
}
//将bytes中的字符统计放入集合中
private static List<Node> getNodes(byte[] bytes) {
//创建一个ArrayList
ArrayList<Node> nodes = new ArrayList<Node>();
//遍历bytes，统计每一个byte出现的次数
HashMap<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对象，并加入到List集合
//遍历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);
//创建一颗新的二叉树，他的根节点没有data，只有权值
Node parent = new Node(null, leftNode.weight+rightNode.weight);
parent.left = leftNode;
parent.right = rightNode;
//将已经处理的俩颗二叉树移除
nodes.remove(leftNode);
nodes.remove(rightNode);
//将新的二叉树加入nodes
nodes.add(parent);
}
//将赫夫曼树的根节点返回
return nodes.get(0);
}
}
class Node implements Comparable<Node>{
Byte data;//存放数据(字符)本身
int weight;//权值，表示字符出现的次数
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public int compareTo(Node o) {
// TODO Auto-generated method stub
return this.weight - o.weight;
}
@Override
public String toString() {
return "Node [data=" + data + ", weight=" + weight + "]";
}
//前序遍历
public void preOrader() {
System.out.println(this);
if (this.left != null) {
this.left.preOrader();
}
if (this.right != null) {
this.right.preOrader();
}
}
}
赫夫曼编码压缩文件注意事项
1)如果文件本身就是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化,比如视频,ppt等等文件
2)赫夫曼编码是按字节来处理的，因此可以处理所有的文件(二进制文件、文本文件)
3)如果一个文件中的内容，重复的数据不多，压缩效果也不会很明显.
扫一扫
923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
