一、赫夫曼树
基本介绍:
1、给定n个权值作为n个叶子结点,构造一棵二叉树,若该树的带权路径长度(wpl)达到最小,称这样的二叉树为最优二叉树,也称为赫夫曼树
2、赫夫曼树是带权路径长度最短的树,权值较大的结点离根较近
1、路径和路径长度:在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1
2、结点的权和带权路径长度:若将树中结点赋给一个有着某种含义的数值,则这个数值称为该结点的权。结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积
3、树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和,记为WPL(weighted path length),权值越大的结点离根结点越近的二叉树才是最优二叉树
4、WPL最小的就是赫夫曼树
构成赫夫曼树的步骤:
1、从小到大进行排序,将每一个数据,每个数据都是一个结点,每个结点可以看成是一棵最简单的二叉树
2、取出根结点权值最小的两棵二叉树
3、组成一棵新的二叉树,该新的二叉树的根结点的权值是前面两棵二叉树根结点权值的和
4、再将这颗新的二叉树,以根结点的权值大小再次排序,不断重复1234步骤,直到数列中,所有的数据都被处理,就得到一棵赫夫曼树
package huffmantree;
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);
}
//创建赫夫曼树的方法
/**
*
* @param arr 需要创建成赫夫曼树的数组
* @return 创建好后的赫夫曼树的root结点
*/
public static Node createHuffmanTree(int[] arr){
//第一步为了操作方便
/*
1、遍历arr数组
2、将arr的每个元素构成一个Node
3、将Node放入到ArrayList中
*/
List<Node> nodes = new ArrayList<>();
for (int value : arr) {
nodes.add(new Node(value));
}
while (nodes.size() > 1){
//升序排序
Collections.sort(nodes);
//System.out.println(nodes);
//取出根结点权值最小的两棵二叉树
//1、取出权值最小的结点
Node leftNode = nodes.get(0);
//2、取出权值第二小的结点
Node rightNode = nodes.get(1);
//3、构建一棵新的二叉树
Node parent = new Node(leftNode.value + rightNode.value);
parent.left = leftNode;
parent.right = rightNode;
//4、从ArrayList删除处理过的二叉树
nodes.remove(leftNode);
nodes.remove(rightNode);
//5、将parent加入到nodes
nodes.add(parent);
}
//返回最后结点,赫夫曼树的root结点
return nodes.get(0);
}
//编写前序遍历的方法
public static void preOrder(Node root){
if (root != null) {
root.preOrder();
} else {
System.out.println("空树,无法遍历");
}
}
}
//创建结点类
//为了让Node对象支持Collections集合排序
//让Node实现Comparable接口
class Node implements Comparable<Node>{
int value;//结点权值
Node left;//指向左子结点
Node right;//指向右子结点
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;
}
//前序遍历
public void preOrder(){
System.out.println(this);
if (this.left != null){
this.left.preOrder();
}
if (this.right != null){
this.right.preOrder();
}
}
}
二、赫夫曼编码
赫夫曼编码也叫哈夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式,属于一种程序算法,赫夫曼编码广泛地用于数据文件压缩,其压缩率通常在20%-90%之间。
注意:
赫夫曼树根据排序方法不同,也可能不太一样,这样对应的赫夫曼编码也不完全一样,但是wpl是一样的,都是最小的,最后生成的赫夫曼编码的长度是一样的
2.1 数据压缩-创建赫夫曼树
功能:根据赫夫曼编码压缩数据的原理,需要创建"i 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[data=7,weight=5],Node[data=32,weight=9]…}
4、通过List创建对应的赫夫曼树
//通过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,只有权值
Node parent = new Node(null, leftNode.weight + rightNode.weight);
parent.left = leftNode;
parent.right = rightNode;
//将已经处理的两棵二叉树从nodes移除
nodes.remove(leftNode);
nodes.remove(rightNode);
//将新的二叉树加入到nodes
nodes.add(parent);
}
//nodes最后的结点就是赫夫曼树的根结点
return nodes.get(0);
}
2.2 生成赫夫曼编码和赫夫曼编码后的数据
//生成赫夫曼树对应的赫夫曼编码
//思路:
//1、将赫夫曼编码表存放在Map<Byte,String>
static Map<Byte, String> huffmanCodes = new HashMap<>();
//2、在生成赫夫曼编码表时,需要去拼接路径,定义一个StringBuilder存储某个叶子结点的路径
static StringBuilder stringBuilder = new StringBuilder();
//为了调用方便,我们重载getCodes
private static Map<Byte, String> getCodes(Node root){
if (root == null){
return null;
}
//处理root左子树
getCodes(root.left,"0",stringBuilder);
//处理root右子树
getCodes(root.right,"1",stringBuilder);
return huffmanCodes;
}
/**
* 功能:将传入的node结点的所有叶子结点的赫夫曼编码得到,并放入到huffmanCodes集合
* @param node 传入结点
* @param code 路径:左子结点是0,右子结点是1
* @param stringBuilder 用于拼接路径
*/
private static void getCodes(Node node, String code, StringBuilder stringBuilder){
StringBuilder stringBuilder1 = new StringBuilder(stringBuilder);
//将Code加入到stringBuilder1
stringBuilder1.append(code);
if (node != null){//如果node == null不处理
//判断当前node是叶子结点还是非叶子结点
if (node.data == null){//非叶子结点
//递归处理
//向左递归
getCodes(node.left, "0", stringBuilder1);
//向右递归
getCodes(node.right, "1", stringBuilder1);
}else {//说明是一个叶子结点
//就表示找到某个叶子结点的最后
huffmanCodes.put(node.data, stringBuilder1.toString());
}
}
}
2.3 数据解压-使用赫夫曼编码解码
/**
* 将一个byte转成一个二进制字符串
* @param b 传入的byte
* @param flag 表示标识是否需要补高位,如果为true,表示需要补高位,如果是false表示不补
* @return 是该b对应的二进制字符串(注意:按照补码返回)
*/
private static String byteToBitString(boolean flag, byte b){
//使用变量保存b
int temp = b;//将b转成int
//如果是正数我们还存在补高位
if (flag){
temp |= 256;//按位或
}
String str = Integer.toBinaryString(temp);//返回的是temp对应的二进制补码
if (flag){
return str.substring(str.length() - 8);
}else {
return str;
}
}
//完成数据的解压
//思路
//1、将huffmanCodeBytes重新先转成赫夫曼编码对应的二进制字符串
//2、赫夫曼编码对应的二进制字符串对照赫夫曼编码进行解码
//编写完成对压缩数据的解码
/**
*
* @param huffmanCodes 赫夫曼编码表
* @param huffmanBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes){
//1、先得到huffmanBytes对应的二进制字符串
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));
}
//System.out.println(stringBuilder.toString());
//把字符串按照指定的赫夫曼编码进行解码
//把赫夫曼编码表进行调换
Map<String, Byte> map = new HashMap<>();
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){
//递增取出key
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;
}
2.4 文件压缩
//编写方法,将一个文件进行压缩
/**
*
* @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) {
System.out.println(e.getMessage());
} finally {
try {
is.close();
oos.close();
os.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
2.5 文件解压(文件恢复)
//编写方法,完成对压缩文件的解压
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){
System.out.println(e2.getMessage());
}
}
}
赫夫曼编码压缩文件注意事项
1、如果文件本身就是经过压缩处理的,那么使用赫夫曼编码再压缩效率不会有明显变化,比如视频、ppt等文件
2、赫夫曼编码是按字节来处理的,因此可以处理所有的文件(二进制文件、文本文件)
3、如果一个文件中的内容,重复的数据不多,压缩效果也不会很明显
2.6 代码汇总
package huffmancode;
import java.io.*;
import java.util.*;
public class HuffmanCode {
public static void main(String[] args) {
//测试压缩文件
/*String srcFile = "E:\\123.tif";
String dstFile = "E:\\1.zip";
zipFile(srcFile, dstFile);
System.out.println("压缩文件ok");*/
//测试解压文件
String zipFile = "E:\\1.zip";
String dstFile = "E:\\1234.tif";
unzipFile(zipFile,dstFile);
System.out.println("解压文件ok");
/*
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);//40
byte[] huffmanCodeBytes = huffmanZip(contentBytes);
System.out.println(Arrays.toString(huffmanCodeBytes));
byte[] sourceBytes = decode(huffmanCodes, huffmanCodeBytes);
System.out.println("原来的字符串=" + new String(sourceBytes));
*/
/*
分步过程
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//测试创建的二叉树
System.out.println("赫夫曼树");
Node huffmanTreeRoot = createHuffmanTree(nodes);
System.out.println("前序遍历");
preOrder(huffmanTreeRoot);
//测试是否生成了对应的赫夫曼编码
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
System.out.println("生成的赫夫曼编码表");//{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
System.out.println(huffmanCodes);
byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
System.out.println("赫夫曼编码压缩后的byte数组");//[-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
System.out.println(Arrays.toString(huffmanCodeBytes));
*/
}
//编写方法,完成对压缩文件的解压
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){
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) {
System.out.println(e.getMessage());
} finally {
try {
is.close();
oos.close();
os.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
//完成数据的解压
//思路
//1、将huffmanCodeBytes重新先转成赫夫曼编码对应的二进制字符串
//2、赫夫曼编码对应的二进制字符串对照赫夫曼编码进行解码
//编写完成对压缩数据的解码
/**
*
* @param huffmanCodes 赫夫曼编码表
* @param huffmanBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes){
//1、先得到huffmanBytes对应的二进制字符串
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));
}
//System.out.println(stringBuilder.toString());
//把字符串按照指定的赫夫曼编码进行解码
//把赫夫曼编码表进行调换
Map<String, Byte> map = new HashMap<>();
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){
//递增取出key
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 b 传入的byte
* @param flag 表示标识是否需要补高位,如果为true,表示需要补高位,如果是false表示不补
* @return 是该b对应的二进制字符串(注意:按照补码返回)
*/
private static String byteToBitString(boolean flag, byte b){
//使用变量保存b
int temp = b;//将b转成int
//如果是正数我们还存在补高位
if (flag){
temp |= 256;//按位或
}
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> nodes = getNodes(bytes);
//创建二叉树
Node huffmanTreeRoot = createHuffmanTree(nodes);
//生成对应的赫夫曼编码
Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
//赫夫曼编码压缩后的byte数组
byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
return huffmanCodeBytes;
}
//编写方法,将字符串对应的byte[]数组,通过生成的赫夫曼编码表,返回一个赫夫曼编码压缩后的byte[]
/**
*
* @param bytes 这是原始的字符串对应的byte[]
* @param huffmanCodes huffmanCodes生成的赫夫曼编码表
* @return 返回赫夫曼编码处理后的byte[]
* byte[] huffmanCodeBytes 即8位对应一个byte,放入到huffmanCodeBytes
* 例如:huffmanCodeBytes[0] = 10101000(补码) => byte 推导出-88
*/
private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes){
//1、利用huffmanCodes将bytes转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
//遍历bytes数组
for(byte b : bytes){
stringBuilder.append(huffmanCodes.get(b));
}
//1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100
//System.out.println(stringBuilder.toString());
//将”1010100...“转成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>
static Map<Byte, String> huffmanCodes = new HashMap<>();
//2、在生成赫夫曼编码表时,需要去拼接路径,定义一个StringBuilder存储某个叶子结点的路径
static StringBuilder stringBuilder = new StringBuilder();
//为了调用方便,我们重载getCodes
private static Map<Byte, String> getCodes(Node root){
if (root == null){
return null;
}
//处理root左子树
getCodes(root.left,"0",stringBuilder);
//处理root右子树
getCodes(root.right,"1",stringBuilder);
return huffmanCodes;
}
/**
* 功能:将传入的node结点的所有叶子结点的赫夫曼编码得到,并放入到huffmanCodes集合
* @param node 传入结点
* @param code 路径:左子结点是0,右子结点是1
* @param stringBuilder 用于拼接路径
*/
private static void getCodes(Node node, String code, StringBuilder stringBuilder){
StringBuilder stringBuilder1 = new StringBuilder(stringBuilder);
//将Code加入到stringBuilder1
stringBuilder1.append(code);
if (node != null){//如果node == null不处理
//判断当前node是叶子结点还是非叶子结点
if (node.data == null){//非叶子结点
//递归处理
//向左递归
getCodes(node.left, "0", stringBuilder1);
//向右递归
getCodes(node.right, "1", stringBuilder1);
}else {//说明是一个叶子结点
//就表示找到某个叶子结点的最后
huffmanCodes.put(node.data, stringBuilder1.toString());
}
}
}
//前序遍历
private static void preOrder(Node root){
if (root != null){
root.preOrder();
}else {
System.out.println("赫夫曼树为空");
}
}
/**
*
* @param bytes 接收字节数组
* @return 返回的就是List
*/
private static List<Node> getNodes(byte[] bytes){
//创建一个ArrayList
ArrayList<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;
}
//通过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,只有权值
Node parent = new Node(null, leftNode.weight + rightNode.weight);
parent.left = leftNode;
parent.right = rightNode;
//将已经处理的两棵二叉树从nodes移除
nodes.remove(leftNode);
nodes.remove(rightNode);
//将新的二叉树加入到nodes
nodes.add(parent);
}
//nodes最后的结点就是赫夫曼树的根结点
return nodes.get(0);
}
}
//创建Node,带数据和权值
class Node implements Comparable<Node>{
Byte data;//存放数据(字符)本身。比如'a'=> 97...
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();
}
}
}