目录
【赫夫曼树】
赫夫曼树（最优二叉树），也有其他译名，它的本质就是所有叶子结点的带权路径长度之和最小的二叉树，所有叶子结点的带权路径长度又叫WPL（weighted path length）。WPL=所有叶子结点权值*路径长度之和，如下3种树，中间这个树的排列方式，使得wpl最小，所以它属于赫夫曼树。
赫夫曼树的特点就在于：结点权值越大的与根节点离得越近
如何创建一个赫夫曼树？
第一步：将权值数组中的数据包装入事先创建好的结点类中，结点类的num保存权值，然后将每一个结点放入到动态数组（ArrayList）中
第二步：将这些动态数组中的节点按照权值的大小进行排序。
第三步：取出权值最小的两个节点，并创建一个新的节点作为这两个节点的父节点，这个父节点的权值为两个子节点的权值之和。将这两个节点分别赋给父节点的左右节点。
第四步：删除这两个节点，将父节点添加进动态数组里。
第五步：重复第二步到第四步，直到集合中只剩一个元素，结束循环。此时剩余的元素就是赫夫曼树的根节点
代码实现：
package cn.dataStructureAndAlgorithm.demo.tree;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Node_HT implements Comparable<Node_HT>{
private int num;
private Node_HT left;
private Node_HT right;
public Node_HT(int num) {
this.num = num;
}
public void setLeft(Node_HT left) {
this.left = left;
}
public void setRight(Node_HT right) {
this.right = right;
}
public Node_HT getLeft() {
return left;
}
public Node_HT getRight() {
return right;
}
public int getNum() {
return num;
}
@Override
public String toString() {
return "Node_HT{" +
"num=" + num +
'}';
}
@Override
public int compareTo(Node_HT o) {
return this.num-o.num;//表示升序
}
}
public class 赫夫曼树_HuffmanTree {
public static void main(String[] args) {
int data[]=new int[]{13,7,8,3,29,6,1};
Node_HT huffmanTree=huffmanTree(data);
preOrder(huffmanTree);
}
public static void preOrder(Node_HT node){
System.out.println(node);
if (node.getLeft()!=null){
preOrder(node.getLeft());
}
if (node.getRight()!=null){
preOrder(node.getRight());
}
}
public static Node_HT huffmanTree(int[] data) {
List<Node_HT> nodeList = new ArrayList();//动态数组容纳数据
//遍历数组，将其包装入Node类，并包装入动态数组中
for (int i=0;i<data.length;i++){
nodeList.add(new Node_HT(data[i]));
}
//创建赫夫曼树
while (nodeList.size()>1){//当只剩下一个结点时，说明赫夫曼树已经创建成功
Collections.sort(nodeList);//Node类要实现Comparable接口，才能进行排序
//获取前两个小结点，进行子树的创建
Node_HT leftNode=nodeList.get(0);
Node_HT rightNode=nodeList.get(1);
Node_HT parent=new Node_HT(leftNode.getNum()+rightNode.getNum());
parent.setLeft(leftNode);
parent.setRight(rightNode);
//将创建的子树加入到动态数组中，并删除两个小节点
nodeList.remove(1);
nodeList.remove(0);
nodeList.add(parent);
}
//循环完成，动态数组中只剩下一个结点，这个结点就是赫夫曼树的根节点
return nodeList.get(0);
}
}
赫夫曼编码
前排提示：复杂且难 ，但学完后可以自制压缩工具，满满的成就感 ：>
赫夫曼编码是赫夫曼树的一种应用，赫夫曼编码可以有效的压缩数据（压缩率：20%~90%）。
一般编码数据的过程是这样的：
yes（字符串）---> 121 101 115（ASCII）---> 011110101 01100101 01110011（二进制）
数据由3个字符变化为27个字符，这种编码方式称为可变字长编码，但这种编码存在一种前缀二义性的问题：当识别到前缀0111后，对应了两个字节组 011110101与01110011，无法区分。
赫夫曼编码就是一种可变字长编码。赫夫曼编码主要解决的问题在于如何把27个字符进一步的缩减，和解决前缀二义性的问题。
赫夫曼编码：
yes（字符串）---> y:1 e:1 s:1（字符:出现次数）---> 以出现字符次数为权值建立赫夫曼树，如下图 --->根据赫夫曼树，给各个字符规定编码（前缀编码），向左的路径为0，向右的路径为1，如下图 ---> y:00 e:01 s:1（字符:前缀）---> 00011（赫夫曼编码）
以上将“yes”变为“00011”，用y=00 e=01 s=1的形式替换字符，这样不存在前缀二义性问题且压缩了数据
ps：当存在权值相同的结点时，由于排序算法的不稳定性，相同结点可能具有多种位置，所形成的赫夫曼树也有多种。但他们的wpl是一样的，形成的赫夫曼编码位数相同。
分步代码实现：
【1】完成字符出现次数记录，与赫夫曼树的建立
package cn.dataStructureAndAlgorithm.demo.tree;
import java.util.*;
class Node_HC implements Comparable<Node_HC>{
private int weight;
private Byte data;
private Node_HC left;
private Node_HC right;
public Node_HC(int weight,Byte data) {
this.weight = weight;
this.data=data;
}
public void setLeft(Node_HC left) {
this.left = left;
}
public void setRight(Node_HC right) {
this.right = right;
}
public Node_HC getLeft() {
return left;
}
public Node_HC getRight() {
return right;
}
public int getWeight() {
return weight;
}
@Override
public String toString() {
return "Node_HC{" +
"weight=" + weight +
'}';
}
@Override
public int compareTo(Node_HC o) {
return this.weight-o.weight;//表示升序
}
}
public class 赫夫曼编码_HuffmanCode {
public static void main(String[] args) {
String str="hello world!";
preOrder(huffmanCode(str));
}
public static Node_HC huffmanCode(String str){
//将字符串转为字节数组
byte[] byteStr=str.getBytes();
//map集合用于把byteStr中的相同字节组合出现的次数进行统计
Map<Byte,Integer> counts= new HashMap<>();
//ArraysList集合用于把map集合中的数据包装入结点类中，并保存在动态数组集合中
List<Node_HC> nodeList=new ArrayList<>();
//字节组统计
for (byte temp:byteStr) {
Integer count=counts.get(temp);//获取temp对应的次数
if (count==null){//还未保存temp的次数
counts.put(temp,1);//初始化temp次数
}else {//保存有temp的次数
counts.put(temp,count+1);//temp次数加一
}
}
//map集合数据入list集合
for (Map.Entry<Byte,Integer> temp:counts.entrySet()){
nodeList.add(new Node_HC(temp.getValue(),temp.getKey()));
}
return huffmanTree(nodeList);
}
public static Node_HC huffmanTree(List<Node_HC> nodeList){
while (nodeList.size()>1){
Collections.sort(nodeList);
Node_HC leftNode =nodeList.get(0);
Node_HC rightNode=nodeList.get(1);
Node_HC parent=new Node_HC(leftNode.getWeight()+rightNode.getWeight(),null );//父节点只保存权重，不保存内容
parent.setLeft(leftNode);
parent.setRight(rightNode);
nodeList.remove(leftNode);
nodeList.remove(rightNode);
nodeList.add(parent);
}
return nodeList.get(0);
}
public static void preOrder(Node_HC node){
System.out.println(node);
if (node.getLeft()!=null){
preOrder(node.getLeft());
}
if (node.getRight()!=null){
preOrder(node.getRight());
}
}
}
测试结果：
Node_HC{weight=12}
Node_HC{weight=5}
Node_HC{weight=2}
Node_HC{weight=1}
Node_HC{weight=1}
Node_HC{weight=3}
Node_HC{weight=7}
Node_HC{weight=3}
Node_HC{weight=1}
Node_HC{weight=2}
Node_HC{weight=4}
Node_HC{weight=2}
Node_HC{weight=1}
Node_HC{weight=1}
Node_HC{weight=2}
Node_HC{weight=1}
Node_HC{weight=1}【2】在主类中新增getCodes方法，用于根据传入的赫夫曼树，以左路径为0，右路径为1 的形式获取叶子结点对应字符的赫夫曼编码
/**
* 根据传入的赫夫曼树，以左路径为0，右路径为1 的形式获取叶子结点对应的字符赫夫曼编码表
* @param node 赫夫曼树的根节点
* @param stringBuilder 用来保存上一次递归中的拼凑路径
* @param huffmanCodes 用来保存叶子结点对应的赫夫曼编码
*/
public static void getCodes(Node_HC node,String code,StringBuilder stringBuilder,Map<Byte,String> huffmanCodes){
StringBuilder stringBuilder2=new StringBuilder(stringBuilder);//stringBulider2保存上一次的字符串内
stringBuilder2.append(code);//将当前路径代码（0/1）拼接到上一次递归的字符串中
if (node!=null){//node为空不操作
if (node.getData()==null){//非叶子结点，继续递归
//左递归
getCodes(node.getLeft(),"0",stringBuilder2,huffmanCodes);
//右递归
getCodes(node.getRight(),"1",stringBuilder2,huffmanCodes);
}else {
//保存叶子结点对应的赫夫曼编码
huffmanCodes.put(node.getData(),stringBuilder2.toString());
}
}
}另外修改了huffmanCode方法，用于和新方法getCode进行对接
/**
* 赫夫曼编码操作总方法
* @param str 需要编码的字符串
* @return 字符串对应的赫夫曼编码表（测试）
*/
public static Map<Byte, String> huffmanCode(String str) {
//将字符串转为字节数组
byte[] byteStr = str.getBytes();
//map集合用于把byteStr中的相同字节组合出现的次数进行统计
Map<Byte, Integer> counts = new HashMap<>();
//ArraysList集合用于把map集合中的数据包装入结点类中，并保存在动态数组集合中
List<Node_HC> nodeList = new ArrayList<>();
//字节组统计
for (byte temp : byteStr) {
Integer count = counts.get(temp);//获取temp对应的次数
if (count == null) {//还未保存temp的次数
counts.put(temp, 1);//初始化temp次数
} else {//保存有temp的次数
counts.put(temp, count + 1);//temp次数加一
}
}
//map集合数据入list集合
for (Map.Entry<Byte, Integer> temp : counts.entrySet()) {
nodeList.add(new Node_HC(temp.getValue(), temp.getKey()));
}
//-------------------新增部分---------------------------------------------------
//创建赫夫曼树，并获取赫夫曼编码
Map<Byte,String> huffmanCodes=new HashMap();//赫夫曼编码表
getCodes(huffmanTree(nodeList),"",new StringBuilder(),huffmanCodes);
return huffmanCodes;
}主方法中添加测试语句，输出得到的赫夫曼编码表
System.out.println(huffmanCode(str));测试结果：
{32=1100, 33=1101, 114=1110, 100=1111, 101=000, 119=001, 104=100, 108=01, 111=101}【3】在主类新增tohuffmanString方法，用于按照赫夫曼编码表，将待编码的字符串转为赫夫曼字符串（即字符按顺序转换成对应的赫夫曼编码，并拼接在一起，形成所谓赫夫曼字符串）
/**
* 按照赫夫曼编码表，将待编码的字符串转为赫夫曼字符串
* @param str 待编码的字符串
* @param huffmanCodes 赫夫曼编码表
* @return 赫夫曼字符串
*/
public static String toHuffmanString(String str,Map<Byte,String> huffmanCodes){
StringBuilder stringBuilder=new StringBuilder();//用于拼接成赫夫曼字符串
byte[] strByte=str.getBytes();//将待编码的数据，转换为字符数组
//按照赫夫曼编码表，将待编码的字符串转为赫夫曼字符串
for (byte temp:strByte) {
stringBuilder.append(huffmanCodes.get(temp));
}
return stringBuilder.toString();
}另外修改了huffmanCode方法，用于和新方法toHuffmanString进行对接
/**
* 赫夫曼编码操作总方法
* @param str 需要编码的字符串
* @return 字符串对应的赫夫曼字符串（测试）
*/
public static String huffmanCode(String str) {
//将字符串转为字节数组
byte[] byteStr = str.getBytes();
//map集合用于把byteStr中的相同字节组合出现的次数进行统计
Map<Byte, Integer> counts = new HashMap<>();
//ArraysList集合用于把map集合中的数据包装入结点类中，并保存在动态数组集合中
List<Node_HC> nodeList = new ArrayList<>();
//字节组统计
for (byte temp : byteStr) {
Integer count = counts.get(temp);//获取temp对应的次数
if (count == null) {//还未保存temp的次数
counts.put(temp, 1);//初始化temp次数
} else {//保存有temp的次数
counts.put(temp, count + 1);//temp次数加一
}
}
//map集合数据入list集合
for (Map.Entry<Byte, Integer> temp : counts.entrySet()) {
nodeList.add(new Node_HC(temp.getValue(), temp.getKey()));
}
//创建赫夫曼树，并获取赫夫曼编码
Map<Byte,String> huffmanCodes=new HashMap();//赫夫曼编码表
getCodes(huffmanTree(nodeList),"",new StringBuilder(),huffmanCodes);//建树，获取编码
//----------------------------------新增部分-----------------------------------------
//获取赫夫曼字符串
return toHuffmanString(str,huffmanCodes);
}测试结果：
1000000101101110000110111100111111101【4】在主类新增zip方法，用于将赫夫曼字符串压缩成字节数组
/**
* 将赫夫曼字符串压缩成字节数组
* @param huffmanStr 赫夫曼字符串
* @return 压缩的字节数组
*/
public static byte[] zip(String huffmanStr){
//将赫夫曼字符串按8位截断，并按照二进制转字节的方式转为字节数组，起到压缩的效果
int len=(huffmanStr.length()+7)/8;//巧妙的算法：将字符串按8位拆分，不够8位的按8位拆分
byte[] huffmanCodeByte=new byte[len];//存储压缩后的数据
int index=0;//存储索引
String byteStr;//存储拆分后的字符串
//将赫夫曼字符串8位截断后，压缩成字节数组
for (int i=0;i<huffmanStr.length();i+=8){
if (i+8>huffmanStr.length()){//不够8位
byteStr=huffmanStr.substring(i);
}else {//够8位
byteStr=huffmanStr.substring(i,i+8);
}
huffmanCodeByte[index]=(byte)Integer.parseInt(byteStr,2);//按照二进制转字节的方式转为字节数组
index++;
}
return huffmanCodeByte;
}另外修改了huffmanCode方法，将其方法名改为huffmanZip，用于和新方法zip进行对接
/**
* 赫夫曼编码操作总方法
* @param str 需要编码的字符串
* @return 字符串对应的压缩字节数组（测试）
*/
public static byte[] huffmanZip(String str) {
//将字符串转为字节数组
byte[] byteStr = str.getBytes();
//map集合用于把byteStr中的相同字节组合出现的次数进行统计
Map<Byte, Integer> counts = new HashMap<>();
//ArraysList集合用于把map集合中的数据包装入结点类中，并保存在动态数组集合中
List<Node_HC> nodeList = new ArrayList<>();
//字节组统计
for (byte temp : byteStr) {
Integer count = counts.get(temp);//获取temp对应的次数
if (count == null) {//还未保存temp的次数
counts.put(temp, 1);//初始化temp次数
} else {//保存有temp的次数
counts.put(temp, count + 1);//temp次数加一
}
}
//map集合数据入list集合
for (Map.Entry<Byte, Integer> temp : counts.entrySet()) {
nodeList.add(new Node_HC(temp.getValue(), temp.getKey()));
}
//创建赫夫曼树，并获取赫夫曼编码
Map<Byte,String> huffmanCodes=new HashMap();//赫夫曼编码表
getCodes(huffmanTree(nodeList),"",new StringBuilder(),huffmanCodes);//建树，获取编码
//----------------------------------新增部分-----------------------------------------
//通过获取赫夫曼字符串，得到压缩字节数组
return zip(toHuffmanString(str,huffmanCodes));
}主方法中添加测试语句，输出得到的压缩后的字节数组：
System.out.println(Arrays.toString(huffmanZip(str)));测试结果：
[-127, 110, 27, -49, 29]【5】在主类中新增huffmanUnZip，toBinary方法，前者提供解码文件的功能，后者为前者提供字节转二进制字符串的服务。
/**
*解码文件
* @param huffmanCodeByte 待解码文件的字节数组
* @return 解码后的字符串
*/
public static String huffmanUnZip(byte[] huffmanCodeByte){
StringBuilder stringBuilder=new StringBuilder();
for (byte temp:huffmanCodeByte) {
if (temp!=huffmanCodeByte[huffmanCodeByte.length-1]){
stringBuilder.append(toBinary(true,temp));
}else {
stringBuilder.append(toBinary(false,temp));
}
}
Map<String,Byte> reverseHuffmanCodes=new HashMap<>();
for (Map.Entry<Byte,String> temp: huffmanCodes.entrySet()) {
reverseHuffmanCodes.put(temp.getValue(),temp.getKey());
}
int index=1;
String key;
Byte b;
List<Byte> result=new ArrayList<>();
for (int i=0;i<stringBuilder.length();){
while (true){
key=stringBuilder.substring(i,i+index);
b=reverseHuffmanCodes.get(key);
if (b==null){
index++;
}else {
break;
}
}
result.add(b);
i+=index;
index=1;
}
byte[] stringByte = new byte[result.size()];
for (int i=0;i<stringByte.length;i++){
stringByte[i]=result.get(i);
}
return new String(stringByte);
}/**
*将字节转为二进制字符串
* @param flag 是否要部高位
* @param huffmanCodeByte 字节
* @return 二进制字符串
*/
public static String toBinary(boolean flag,byte huffmanCodeByte){
int temp=huffmanCodeByte;//字节转整数
if (flag){//需要补高位
temp|=256;
}
String str = Integer.toBinaryString(temp);
if (flag||temp<0){
return str.substring(str.length()-8);
}else {
return str;
}
}
}主方法中添加测试语句，输出得到的解码后的字符串
System.out.println(huffmanUnZip(huffmanZip(str)));测试结果：
hello world!赫夫曼编码的完整代码：
package cn.dataStructureAndAlgorithm.demo.tree;
import java.util.*;
public class 赫夫曼编码_HuffmanCode {
static Map<Byte,String> huffmanCodes=new HashMap();//全局赫夫曼编码表
public static void main(String[] args) {
String str="hello world!";
System.out.println("编码后："+Arrays.toString(huffmanZip(str)));
System.out.println("解码后："+huffmanUnZip(huffmanZip(str)));
}
/**
* 赫夫曼编码操作总方法
* @param str 需要编码的字符串
* @return 字符串对应的压缩字节数组（测试）
*/
public static byte[] huffmanZip(String str) {
//将字符串转为字节数组
byte[] byteStr = str.getBytes();
//map集合用于把byteStr中的相同字节组合出现的次数进行统计
Map<Byte, Integer> counts = new HashMap<>();
//ArraysList集合用于把map集合中的数据包装入结点类中，并保存在动态数组集合中
List<Node_HC> nodeList = new ArrayList<>();
//字节组统计
for (byte temp : byteStr) {
Integer count = counts.get(temp);//获取temp对应的次数
if (count == null) {//还未保存temp的次数
counts.put(temp, 1);//初始化temp次数
} else {//保存有temp的次数
counts.put(temp, count + 1);//temp次数加一
}
}
//map集合数据入list集合
for (Map.Entry<Byte, Integer> temp : counts.entrySet()) {
nodeList.add(new Node_HC(temp.getValue(), temp.getKey()));
}
//创建赫夫曼树，并获取赫夫曼编码
getCodes(huffmanTree(nodeList),"",new StringBuilder(),huffmanCodes);//建树，获取编码
//----------------------------------新增部分-----------------------------------------
//通过获取赫夫曼字符串，得到压缩字节数组
return zip(toHuffmanString(str,huffmanCodes));
}
/**
* 根据动态数组中的结点创建赫夫曼树
* @param nodeList 包含各结点的动态数组
* @return 赫夫曼树
*/
public static Node_HC huffmanTree(List<Node_HC> nodeList){
while (nodeList.size()>1){
Collections.sort(nodeList);
Node_HC leftNode =nodeList.get(0);
Node_HC rightNode=nodeList.get(1);
Node_HC parent=new Node_HC(leftNode.getWeight()+rightNode.getWeight(),null );//父节点只保存权重，不保存内容
parent.setLeft(leftNode);
parent.setRight(rightNode);
nodeList.remove(leftNode);
nodeList.remove(rightNode);
nodeList.add(parent);
}
return nodeList.get(0);
}
/**
* 根据传入的赫夫曼树，以左路径为0，右路径为1 的形式获取叶子结点对应的字符赫夫曼编码表
* @param node 赫夫曼树的根节点
* @param stringBuilder 用来保存上一次递归中的拼凑路径
* @param huffmanCodes 用来保存叶子结点对应的赫夫曼编码
*/
public static void getCodes(Node_HC node,String code,StringBuilder stringBuilder,Map<Byte,String> huffmanCodes){
StringBuilder stringBuilder2=new StringBuilder(stringBuilder);//stringBulider2保存上一次的字符串内
stringBuilder2.append(code);//将当前路径代码（0/1）拼接到上一次递归的字符串中
if (node!=null){//node为空不操作
if (node.getData()==null){//非叶子结点，继续递归
//左递归
getCodes(node.getLeft(),"0",stringBuilder2,huffmanCodes);
//右递归
getCodes(node.getRight(),"1",stringBuilder2,huffmanCodes);
}else {
//保存叶子结点对应的赫夫曼编码
huffmanCodes.put(node.getData(),stringBuilder2.toString());
}
}
}
/**
* 按照赫夫曼编码表，将待编码的字符串转为赫夫曼字符串
* @param str 待编码的字符串
* @param huffmanCodes 赫夫曼编码表
* @return 赫夫曼字符串
*/
public static String toHuffmanString(String str,Map<Byte,String> huffmanCodes){
StringBuilder stringBuilder=new StringBuilder();//用于拼接成赫夫曼字符串
byte[] strByte=str.getBytes();//将待编码的数据，转换为字符数组
//按照赫夫曼编码表，将待编码的字符串转为赫夫曼字符串
for (byte temp:strByte) {
stringBuilder.append(huffmanCodes.get(temp));
}
return stringBuilder.toString();
}
/**
* 将赫夫曼字符串压缩成字节数组
* @param huffmanStr 赫夫曼字符串
* @return 压缩的字节数组
*/
public static byte[] zip(String huffmanStr){
//将赫夫曼字符串按8位截断，并按照二进制转字节的方式转为字节数组，起到压缩的效果
int len=(huffmanStr.length()+7)/8;//巧妙的算法：将字符串按8位拆分，不够8位的按8位拆分
byte[] huffmanCodeByte=new byte[len];//存储压缩后的数据
int index=0;//存储索引
String byteStr;//存储拆分后的字符串
//将赫夫曼字符串8位截断后，压缩成字节数组
for (int i=0;i<huffmanStr.length();i+=8){
if (i+8>huffmanStr.length()){//不够8位
byteStr=huffmanStr.substring(i);
}else {//够8位
byteStr=huffmanStr.substring(i,i+8);
}
huffmanCodeByte[index]=(byte)Integer.parseInt(byteStr,2);//按照二进制转字节的方式转为字节数组
index++;
}
return huffmanCodeByte;
}
/**
*解码文件
* @param huffmanCodeByte 待解码文件的字节数组
* @return 解码后的字符串
*/
public static String huffmanUnZip(byte[] huffmanCodeByte){
StringBuilder stringBuilder=new StringBuilder();
for (byte temp:huffmanCodeByte) {
if (temp!=huffmanCodeByte[huffmanCodeByte.length-1]){
stringBuilder.append(toBinary(true,temp));
}else {
stringBuilder.append(toBinary(false,temp));
}
}
Map<String,Byte> reverseHuffmanCodes=new HashMap<>();
for (Map.Entry<Byte,String> temp: huffmanCodes.entrySet()) {
reverseHuffmanCodes.put(temp.getValue(),temp.getKey());
}
int index=1;
String key;
Byte b;
List<Byte> result=new ArrayList<>();
for (int i=0;i<stringBuilder.length();){
while (true){
key=stringBuilder.substring(i,i+index);
b=reverseHuffmanCodes.get(key);
if (b==null){
index++;
}else {
break;
}
}
result.add(b);
i+=index;
index=1;
}
byte[] stringByte = new byte[result.size()];
for (int i=0;i<stringByte.length;i++){
stringByte[i]=result.get(i);
}
return new String(stringByte);
}
/**
*将字节转为二进制字符串
* @param flag 是否要部高位
* @param huffmanCodeByte 字节
* @return 二进制字符串
*/
public static String toBinary(boolean flag,byte huffmanCodeByte){
int temp=huffmanCodeByte;//字节转整数
if (flag){//需要补高位
temp|=256;
}
String str = Integer.toBinaryString(temp);
if (flag||temp<0){
return str.substring(str.length()-8);
}else {
return str;
}
}
}
class Node_HC implements Comparable<Node_HC>{
private int weight;
private Byte data;
private Node_HC left;
private Node_HC right;
public Node_HC(int weight,Byte data) {
this.weight = weight;
this.data=data;
}
public Byte getData() {
return data;
}
public void setLeft(Node_HC left) {
this.left = left;
}
public void setRight(Node_HC right) {
this.right = right;
}
public Node_HC getLeft() {
return left;
}
public Node_HC getRight() {
return right;
}
public int getWeight() {
return weight;
}
@Override
public String toString() {
return "Node_HC{" +
"weight=" + weight +
'}';
}
@Override
public int compareTo(Node_HC o) {
return this.weight-o.weight;//表示升序
}
}运行结果：
编码后：[-127, 110, 27, -49, 29]
解码后：hello world!
压缩与解压文件（赫夫曼编码）
代码实现：
package cn.dataStructureAndAlgorithm.demo.tree;
import java.io.*;
import java.util.*;
public class 赫夫曼压缩文件_HuffmanFileZipAndUnZip {
public static void main(String[] args) {
//测试压缩文件
String srcFile = "E:"+ File.separator+"2020-07-07_123357.png";
String dstFile = "E:"+File.separator+"2020-07-07_123357.zip";
zipFile(srcFile, dstFile);
System.out.println("压缩文件完成");
//测试解压文件
// String zipFile = "E:"+File.separator+"2020-07-07_123357.png";
// String dstFile = "E:"+File.separator+"2020-07-07_123357.zip";
// unZipFile(zipFile, dstFile);
// 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) {
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 (IOException e) {
System.out.println(e.getMessage());
} finally {
try {
is.close();
oos.close();
os.close();
} catch (Exception e) {
// TODO: handle exception
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 huffmanBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
//1. 先得到 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(byteToBitString(!flag, b));
}
//把字符串安装指定的赫夫曼编码进行解码 //把赫夫曼编码表进行调换，因为反向查询 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<>();
//i 可以理解成就是索引,扫描 stringBuilder
for (int i = 0; i < stringBuilder.length(); ) {
int count = 1; // 小的计数器
boolean flag = true;
Byte b = null;
while (flag) {
//1010100010111...
//递增的取出 key 1
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 中就存放了所有的字符 "i like like like java do you like a java"
//把 list 中的数据放入到 byte[] 并返回
byte b[] = new byte[list.size()];
for (int i = 0; i < b.length; i++) {
b[i] = list.get(i);
}
return b;
}
/**
* 将一个 byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的 Java 基础 二进制的原码，反码，
* 补码
*
* @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) {
List<Node_HF> Node_HFs = getNode_HFs(bytes);
//根据 Node_HFs 创建的赫夫曼树
Node_HF huffmanTreeRoot = createHuffmanTree(Node_HFs);
//对应的赫夫曼编码(根据 赫夫曼树)
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
//根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
return huffmanCodeBytes;
}
/**
* @param bytes 这时原始的字符串对应的 byte[]
* @param huffmanCodes 生成的赫夫曼编码 map
* @return 返回赫夫曼编码处理后的 byte[]
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
/**
* 举例: String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes();
* *返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000 101111111100110001001010011011100"
* => 对应的 byte[] huffmanCodeBytes ，即 8 位对应一个 byte,放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000(补码) => byte [推导 10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ]
* huffmanCodeBytes[1] = -88
*/
//1.利用 huffmanCodes 将 bytes 转成 赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
//遍历 bytes 数组
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
//System.out.println("测试 stringBuilder~~~=" + stringBuilder.toString());
//将 "1010100010111111110..." 转成 byte[]
//统计返回 byte[] huffmanCodeBytes 长度
//一句话 int len = (stringBuilder.length() + 7) / 8;
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;//记录是第几个 byte
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, 117=11001, 101=1110, 118=11011, 105=101,121=11010, 106=0010, 107=1111, 108=000, 111=0011}
static Map<Byte, String> huffmanCodes = new HashMap<Byte, String>();
//2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个 StringBuilder 存储某个叶子结点的路径
static StringBuilder stringBuilder = new StringBuilder();
/**
* @param root
* @return
*/
private static Map<Byte, String> getCodes(Node_HF root) {
if (root == null) {
return null;
}
//处理 root 的左子树
getCodes(root.left, "0", stringBuilder);
//处理 root 的右子树
getCodes(root.right, "1", stringBuilder);
return huffmanCodes;
}
/**
* 功能:将传入的 Node_HF 结点的所有叶子结点的赫夫曼编码得到，并放入到 huffmanCodes 集合
*
* @param Node_HF 传入结点
* @param code 路径: 左子结点是 0, 右子结点 1
* @param stringBuilder 用于拼接路径
*/
private static void getCodes(Node_HF Node_HF, String code, StringBuilder stringBuilder) {
StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
//将 code 加入到 stringBuilder2
stringBuilder2.append(code);
if (Node_HF != null) { //如果 Node_HF == null 不处理
//判断当前 Node_HF 是叶子结点还是非叶子结点
if (Node_HF.data == null) { //非叶子结点
//递归处理
//向左递归
getCodes(Node_HF.left, "0", stringBuilder2); //向右递归
getCodes(Node_HF.right, "1", stringBuilder2);
} else { //说明是一个叶子结点
// 就表示找到某个叶子结点的最后
huffmanCodes.put(Node_HF.data, stringBuilder2.toString());
}
}
}
//前序遍历的方法
private static void preOrder(Node_HF root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("赫夫曼树为空");
}
}
/**
* @param bytes 接收字节数组
* @return 返回的就是 List 形式 [Node_HF[date=97 ,weight = 5], Node_HF[]date=32,weight = 9]......]
*/
private static List<Node_HF> getNode_HFs(byte[] bytes) {
//1 创建一个 ArrayList
ArrayList<Node_HF> Node_HFs = new ArrayList<Node_HF>();
//遍历 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_HF 对象，并加入到 Node_HFs 集合 //遍历 map
for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
Node_HFs.add(new Node_HF(entry.getKey(), entry.getValue()));
}
return Node_HFs;
}
//可以通过 List 创建对应的赫夫曼树
private static Node_HF createHuffmanTree(List<Node_HF> Node_HFs) {
while (Node_HFs.size() > 1) {
//排序, 从小到大
Collections.sort(Node_HFs);
//取出第一颗最小的二叉树
Node_HF leftNode_HF = Node_HFs.get(0);
//取出第二颗最小的二叉树
Node_HF rightNode_HF = Node_HFs.get(1);
//创建一颗新的二叉树,它的根节点 没有 data, 只有权值
Node_HF parent = new Node_HF(null, leftNode_HF.weight + rightNode_HF.weight);
parent.left = leftNode_HF;
parent.right = rightNode_HF;
//将已经处理的两颗二叉树从 Node_HFs 删除
Node_HFs.remove(leftNode_HF);
Node_HFs.remove(rightNode_HF);
//将新的二叉树，加入到 Node_HFs
Node_HFs.add(parent);
}
//Node_HFs 最后的结点，就是赫夫曼树的根结点
return Node_HFs.get(0);
}
}
//创建 Node_HF ,待数据和权值
class Node_HF implements Comparable<Node_HF> {
Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
int weight; //权值, 表示字符出现的次数
Node_HF left;//
Node_HF right;
public Node_HF(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public int compareTo(Node_HF o) {
// 从小到大排序
return this.weight - o.weight;
}
public String toString() {
return "Node_HF [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();
}
}
}
有关树结构的其他内容，见下各链接
【数据结构与算法整理总结目录 ：＞】<-- 宝藏在此（doge）
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
