107 大顶堆和小顶堆图解说明
基本介绍：
- 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，，平均时间复杂度均为O(nlogn) ，它也是不稳定排序
- 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆，注意：没有要求结点的左孩子的值和右孩子的值的大小关系
- 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
- 特点：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]。对 i 对应第几个节点，从0开始编号
小顶堆
arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] //对应第几个节点，i从0开始编号
一般升序采用大顶堆，降序采用小顶堆
108 堆排序的思路图解
基本思想：
- 将待排序序列构造成一个大顶堆
- 此时，整个序列的最大值就是堆顶的根节点
- 将其与末尾元素进行交换，此时末尾就为最大值
- 然后将剩余 n - 1 个元素重新构造成一个堆，这样会得到 n 个元素的次小值，如此反复执行，全能得到一个有序序列
在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列
107-110 堆排序代码实现
package com.old.Tree.heapSort_107_110;
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
//要求将数组进行升序排序
int arr[] = {4, 6, 8, 5, 9};
//int arr[] = {4, 6, 8, 5, 9, 99, -999, 100};
heapSort(arr);
}
/**
* 编写一个堆排序的方法
*/
public static void heapSort(int[] arr) {
int temp = 0;
/**分步完成
adjustHeap(arr, 1, arr.length);
//[4, 9, 8, 5, 6]
System.out.println("第一次：" + Arrays.toString(arr));
adjustHeap(arr, 0, arr.length);
//[9, 6, 8, 5, 4]
System.out.println("第一次：" + Arrays.toString(arr));
*/
//最终代码
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
System.out.println("执行：" + Arrays.toString(arr));
/**
* 将堆顶元素与末尾元素交换，将最大元素 沉 到数组末端
* 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复
* 执行调整 + 交换步骤，直到整个序列有序
*/
for (int j = arr.length - 1; j > 0; j--) {
//交换
temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
adjustHeap(arr, 0, j);
}
System.out.println("最后结果：" + Arrays.toString(arr));
}
/**
* 功能：完成将以 i 对应的非叶子节点的树，调整成大顶堆
* 将一个数组（对应二叉树），调整成一个堆
* 举例：int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}
* 如果再次调用 adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9, 6, 8, 5, 4}
*
* @param arr 数组，待调整
* @param i 表示非叶子节点的在数组的索引
* @param length 表示对多个元素进行调整, length 是在逐渐的减少
*/
public static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];
//开始调整
//k = i * 2 + 1 k是i结点的左子节点
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
//说明左子节点小于右子节点的值
if (k + 1 < length && arr[k] < arr[k + 1]) {
//将 k指向右子节点
k++;
}
/**
* 这里的 k 有可能是左子节点，也有可能是右子节点，
* 但是这里总是大的那个
* temp 是父节点是因为，一开始就将 他从数组中取出
*
*
* 如果子节点 大于父节点
*/
if (arr[k] > temp) {
arr[i] = arr[k];
/**
* 这句话很重要，
* 把较大的值，赋给当前结点
*
* i 指向 k 继续循环比较
*/
i = k;
} else {
/**
*
*/
break;
}
}
/**
* 当 for 循环结点后，已经将以 i 为父节点的树的最大值，放在了最顶上（局部）
*
* 将 temp 值放到调整后的位置
*/
arr[i] = temp;
}
}
111 堆排序的速度测试和小结
堆排序的速度非常快，视频测试，8百万的数据3秒左右。O(nlogn)。线性增长的
112-126 赫夫曼树
112 基本介绍
- 给定 n 个权值作为 n 个叶子节点，构造一棵二叉树，若该树的带树路径长度（wpl）达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树（HuffmanTree)，还有的书翻译为霍夫曼树。
- 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近
赫夫曼树的几个重要概念和举例说明
- 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L - 1
- **结点的权及带路径长度：**若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。**结点的带权路径长度为：**从根节点到该结点之间的路径长度与该结点的权的乘积
- 树的带权路径长度：树的带权路径长度规定为所有
叶子结点的带权路径长度之和，记为 WPL(weighted path length），权值越大的结点离根结点越近的二叉树才是最优二叉树。 - WPL最小的就是赫夫曼树
113赫夫曼树创建步骤图解
给一个数列{13，7，8，3，29，6，1}
构成赫夫曼树的步骤
- 从小到大进行的排序，将每一个数据，每个数据都是一个节点，每个节点可以看成是一颗最简单的二叉树
- 取出根节点权值最小的两颗二叉树
- 组成一颗新的二叉树，该新的二叉树根节点的权值是前面两颗二叉树根节点权值的和
- 再将这颗新的二叉树，以根节点的权值大小再次排序，不断重复上面的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树
114 代码实现
package com.old.Tree.huffmanTree_114;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class HuffmanTreeDemo {
public static void main(String[] gda) {
int arr[] = {13, 7, 8, 3, 29, 6, 1};
Node huffmanTree = createHuffmanTree(arr);
preOrder(huffmanTree);
}
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 放入到是 ArrarList 中
*/
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);
//取出权值最小的结点（二叉树）
Node leftNode = nodes.get(0);
//取出权值次第二小的结点
Node rightNode = nodes.get(1);
//构建一颗新的二叉树
Node parent = new Node(leftNode.value + rightNode.value);
parent.left = leftNode;
parent.right = rightNode;
//从arrList中删除处理过的二叉树
nodes.remove(leftNode);
nodes.remove(rightNode);
//将 parent 加入到 nodes
nodes.add(parent);
Collections.sort(nodes);
}
//返回赫夫曼树的root结节
return nodes.get(0);
}
}
/**
* 结点类
* <p>
* 为了让 node 对象，支付排序， Collections 集合排序
* 需要 node 类，实现 Comparable 接口
*/
class Node implements Comparable<Node> {
/**
* 结点权值
*/
int value;
/**
* 左节点
*/
Node left;
/**
* 右子节点
*/
Node right;
public Node(int value) {
this.value = value;
}
/**
* 前序遍历
*/
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
@Override
public int compareTo(Node o) {
/**
* 从小到大排
*/
return this.value - o.value;
}
}
115 变长编码的举例说明
- 赫夫曼验证码也翻译为，
哈夫曼编码（Huffman Coding），又称霍夫曼编码，是一种编码方式，属于一种程序算法 - 赫夫曼编码是赫夫曼树在电讯通信中的经典应用之一
- 赫夫曼编码广泛地用于数据文件压缩。其
压缩率通常在20%~90%之间 - 赫夫曼码是可变字长编码（VLC）的一种，Huffman于1952年提出一种编码方法，称之为最佳编码
116 赫夫曼验证码的原理图解
原理剖析：
注意
这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也完全不一样，但是wpl是一样的，都是最小的，比如：如果我们让每次生成的新的二叉树总是排在权值相同的二叉树的最后一个，则生成的二叉树为
117 创建赫夫曼树思路
118 创建赫夫曼树代码实现
package com.old.Tree.huffmanCode_118;
import java.util.*;
public class HuffmanCodeDemo {
public static void main(String[] args) {
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//创建的二叉树
System.out.println("赫夫曼树：");
Node huffmanTree = createHuffmanTree(nodes);
preOrder(huffmanTree);
}
private static void preOrder(Node root) {
if (root != null) {
root.preOrder();
} else {
System.out.println("树为空，无法遍历");
}
}
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
//取出第一颗最小的二叉树
Node left = nodes.get(0);
//取出第二颗最小的二叉树
Node right = nodes.get(1);
/**
* 创建一颗二叉树
* 它的根节点，没有data，只有权值
*/
Node root = new Node(null, left.weight + right.weight);
root.left = left;
root.right = right;
//将处理过的两颗二叉树移除
nodes.remove(left);
nodes.remove(right);
nodes.add(root);
}
return nodes.get(0);
}
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//存储每个 byte 出现的次数
Map<Byte, Integer> map = new HashMap<>();
for (byte b : bytes) {
//如果有这个 key 表示已经存在了，将次数 ++
if (map.containsKey(b)) {
Integer value = map.get(b);
map.put(b, ++value);
} else {
map.put(b, 1);
}
}
for (Map.Entry<Byte, Integer> entry : map.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
}
/**
* 创建 Node，有数据和权值
*/
class Node implements Comparable<Node> {
/**
* 存储数据本身，比如 a = 97 空格 = 32
*/
Byte data;
/**
* 权值
* 表示字符出现的次数
*/
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
}
119 生成赫夫曼编码表
新增的代码
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;
}
/**
* 生成赫夫曼树对应的赫夫曼编码
* 思路：
* 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}
* <p>
* 2. 在生成赫夫编码表时，需要去拼接路径，定义一个 StringBulder 存储叶子
* 节点的路径
*/
static Map<Byte, String> huffmanCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的 node 节点的所有叶子结点的赫夫曼编码得到，并放入到
* huffmanCodes 集合中
*
* @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);
//如果 node == null 不处理
if (node != null) {
/**
* 判断当前 node 是叶子节点还是非叶子节点
*
* 非叶子节点
*/
if (node.data == null) {
//递归处理
//向左
getCodes(node.left, "0", stringBuilder2);
//向右
getCodes(node.right, "1", stringBuilder2);
} else {
/**
* 说明是一个叶子节点
* 找到某个叶子结点的最后
*/
huffmanCodes.put(node.data, stringBuilder2.toString());
}
}
}
package com.old.Tree.huffmanCode_118;
import java.util.*;
public class HuffmanCodeDemo {
public static void main(String[] args) {
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//创建的二叉树
System.out.println("赫夫曼树：");
Node huffmanTree = createHuffmanTree(nodes);
preOrder(huffmanTree);
//测试是否生成了对应的赫夫曼树
getCodes(huffmanTree);
System.out.println(huffmanCodes);
}
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;
}
/**
* 生成赫夫曼树对应的赫夫曼编码
* 思路：
* 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}
* <p>
* 2. 在生成赫夫编码表时，需要去拼接路径，定义一个 StringBulder 存储叶子
* 节点的路径
*/
static Map<Byte, String> huffmanCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的 node 节点的所有叶子结点的赫夫曼编码得到，并放入到
* huffmanCodes 集合中
*
* @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);
//如果 node == null 不处理
if (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("树为空，无法遍历");
}
}
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
//取出第一颗最小的二叉树
Node left = nodes.get(0);
//取出第二颗最小的二叉树
Node right = nodes.get(1);
/**
* 创建一颗二叉树
* 它的根节点，没有data，只有权值
*/
Node root = new Node(null, left.weight + right.weight);
root.left = left;
root.right = right;
//将处理过的两颗二叉树移除
nodes.remove(left);
nodes.remove(right);
nodes.add(root);
}
return nodes.get(0);
}
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//存储每个 byte 出现的次数
Map<Byte, Integer> map = new HashMap<>();
for (byte b : bytes) {
//如果有这个 key 表示已经存在了，将次数 ++
if (map.containsKey(b)) {
Integer value = map.get(b);
map.put(b, ++value);
} else {
map.put(b, 1);
}
}
for (Map.Entry<Byte, Integer> entry : map.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
}
/**
* 创建 Node，有数据和权值
*/
class Node implements Comparable<Node> {
/**
* 存储数据本身，比如 a = 97 空格 = 32
*/
Byte data;
/**
* 权值
* 表示字符出现的次数
*/
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
}
120 赫夫曼编码字节数组
新增的代码
/**
* 编写一个方法，将一个字符串对应的 byte[] 数组，能过生成的赫夫曼编码表
* 返回一个赫夫曼编压缩后的 byte[] 数组
*
* @param bytes 原始的字符串对应的 byte[]
* @param huffmanCodes 生成赫夫曼编码 map
* @return 返回赫夫曼编码处理后的数组
* "i like like like java do you like a java"; => byte[] contentBytes
* => 对应的 byte[] huffmanCodeBytes , 即 8 位对应一个 byte，放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000（补码） => byte [推导 10101000 =》 10101000 - 1 =》 10100111（反码） =》11011000 = -88 ]
*/
public static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
//1. 利用 huffmanCodes 将 bytes 转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
System.out.println(stringBuilder);
/**
* 统计返回 byte[] huffmanCodeBytes 长度
* 一句话写完：
* int len = (stringBuilder.length() + 7 ) / 8;
* 举例：
* 假如 stringBuilder.length() == 9
* (9 + 7) / 8 依然等于 2
*/
int len;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
//创建存储压缩后的 byte 数组
byte[] huffmanCodeBytes = new byte[len];
//记录第几个 byte
int index = 0;
//因为每8位对应一个 byte ，所以步长 + 8
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 ，放入到
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
全部代码
package com.old.Tree.huffmanCode_118;
import java.util.*;
public class HuffmanCodeDemo {
public static void main(String[] args) {
String strByte = "10101000";
System.out.println((byte) Integer.parseInt(strByte, 2));
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//创建的二叉树
System.out.println("赫夫曼树：");
Node huffmanTree = createHuffmanTree(nodes);
preOrder(huffmanTree);
//测试是否生成了对应的赫夫曼树
getCodes(huffmanTree);
System.out.println(huffmanCodes);
byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
System.out.println("编码过后长度：" + huffmanCodeBytes.length);
System.out.println("编码过后：" + Arrays.toString(huffmanCodeBytes));
}
/**
* 编写一个方法，将一个字符串对应的 byte[] 数组，能过生成的赫夫曼编码表
* 返回一个赫夫曼编压缩后的 byte[] 数组
*
* @param bytes 原始的字符串对应的 byte[]
* @param huffmanCodes 生成赫夫曼编码 map
* @return 返回赫夫曼编码处理后的数组
* "i like like like java do you like a java"; => byte[] contentBytes
* => 对应的 byte[] huffmanCodeBytes , 即 8 位对应一个 byte，放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000（补码） => byte [推导 10101000 =》 10101000 - 1 =》 10100111（反码） =》11011000 = -88 ]
*/
public static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
//1. 利用 huffmanCodes 将 bytes 转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
System.out.println(stringBuilder);
/**
* 统计返回 byte[] huffmanCodeBytes 长度
* 一句话写完：
* int len = (stringBuilder.length() + 7 ) / 8;
* 举例：
* 假如 stringBuilder.length() == 9
* (9 + 7) / 8 依然等于 2
*/
int len;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
//创建存储压缩后的 byte 数组
byte[] huffmanCodeBytes = new byte[len];
//记录第几个 byte
int index = 0;
//因为每8位对应一个 byte ，所以步长 + 8
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 ，放入到
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
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;
}
/**
* 生成赫夫曼树对应的赫夫曼编码
* 思路：
* 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}
* <p>
* 2. 在生成赫夫编码表时，需要去拼接路径，定义一个 StringBulder 存储叶子
* 节点的路径
*/
static Map<Byte, String> huffmanCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的 node 节点的所有叶子结点的赫夫曼编码得到，并放入到
* huffmanCodes 集合中
*
* @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);
//如果 node == null 不处理
if (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("树为空，无法遍历");
}
}
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
//取出第一颗最小的二叉树
Node left = nodes.get(0);
//取出第二颗最小的二叉树
Node right = nodes.get(1);
/**
* 创建一颗二叉树
* 它的根节点，没有data，只有权值
*/
Node root = new Node(null, left.weight + right.weight);
root.left = left;
root.right = right;
//将处理过的两颗二叉树移除
nodes.remove(left);
nodes.remove(right);
nodes.add(root);
}
return nodes.get(0);
}
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//存储每个 byte 出现的次数
Map<Byte, Integer> map = new HashMap<>();
for (byte b : bytes) {
//如果有这个 key 表示已经存在了，将次数 ++
if (map.containsKey(b)) {
Integer value = map.get(b);
map.put(b, ++value);
} else {
map.put(b, 1);
}
}
for (Map.Entry<Byte, Integer> entry : map.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
}
/**
* 创建 Node，有数据和权值
*/
class Node implements Comparable<Node> {
/**
* 存储数据本身，比如 a = 97 空格 = 32
*/
Byte data;
/**
* 权值
* 表示字符出现的次数
*/
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
}
122 赫曼字节数组封装
仅仅是将 main 方法中的代码抽取成了一个方法，这里不做记录
123 字节转二进制字符串
新增的代码
/**
* 将一个 byte 转成一个二进制的字符串
*
* @param b 传入的 byte
* @param flag 标志是否需要补高位，如果是true，表示需要补高位，如果是false表示不补
* @return 是该 b 对应的二进制的字符串，（注意是按补码返回）
*/
private static String byteToString(boolean flag, byte b) {
//使用一个变量 保存 b
int temp = b;
/**
* 如果是正数，还存在补高位
* 按位与
*/
if (flag) {
temp |= 256;
}
String str = Integer.toBinaryString(temp);
System.out.println(str);
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
123 赫夫曼解码
package com.old.Tree.huffmanCode_118;
import java.util.*;
public class HuffmanCodeDemo {
public static void main(String[] args) {
String strByte = "10101000";
System.out.println((byte) Integer.parseInt(strByte, 2));
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
byte[] huffmanCodeBytes = huffmanZip(contentBytes);
System.out.println("编码过后长度：" + huffmanCodeBytes.length);
System.out.println("编码过后：" + Arrays.toString(huffmanCodeBytes));
System.out.println("解码：");
byteToString(false, (byte) 1);
byte[] sourceBytes = decode(huffmanCodes, huffmanCodeBytes);
System.out.println(sourceBytes.length);
System.out.println(new String(sourceBytes));
/**
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//创建的二叉树
System.out.println("赫夫曼树：");
Node huffmanTree = createHuffmanTree(nodes);
preOrder(huffmanTree);
//测试是否生成了对应的赫夫曼树
getCodes(huffmanTree);
System.out.println(huffmanCodes);
byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
System.out.println("编码过后长度：" + huffmanCodeBytes.length);
System.out.println("编码过后：" + Arrays.toString(huffmanCodeBytes));
*/
}
/**
* 完成数据的解压
* 1. 将 huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
* 转成：赫夫曼编码对应的二进制字符串，1010100010111111110010001011111111001000101
* 2. 赫夫曼编码对应的二进制的字符串 "1010100010111111110" 对照赫曼编码 转为文字
*/
/**
* 编写一个方法，完成对压缩数据的解码
*
* @param huffmanCodes 赫夫曼编码表 map
* @param huffmanBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
//1. 先得到 huffmanBytes 对应的二进制的字符串，形式 1010100010111111110
StringBuilder stringBuilder = new StringBuilder();
//将 byte 数组转成二进制的字符串
for (int i = 0; i < huffmanBytes.length; i++) {
boolean flag = (i == huffmanBytes.length - 1);
String s = byteToString(!flag, huffmanBytes[i]);
stringBuilder.append(s);
}
System.out.println("赫夫曼字节数组对应的二进制字符串：");
System.out.println(stringBuilder);
//把字符串按照指定的赫夫曼编码进行解码
//把赫夫曼编码表进行调换，因为反射查的 97 -》 100 100-》？
Map<String, Byte> map = new HashMap<>();
for (Map.Entry<Byte, String> entry : huffmanCodes.entrySet()) {
map.put(entry.getValue(), entry.getKey());
}
System.out.println(map);
//创建集合，存入 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) {
/**
* 取出一个字符串. i 不动，让 count 移动，指定匹配到一个字符
*
*/
String key = stringBuilder.substring(i, i + count);
b = map.get(key);
if (b == null) {
/**
* 说明没有匹配到
*
*/
count++;
} else {
//匹配到
flag = false;
}
}
list.add(b);
/**
* 让 i 直接移动到 count 的位置
* 是因为上面一直在截取字符串，利用 count 不停的 ++ 截取
* 当截取到了，就会跳出循环，而此时说明 从 i 到 count 的
* 都是已经匹配的，所以这里让 i 直接 + = count
* 不是 直接 = 是因为 上面没有给 count 重新赋值
*
*/
i += count;
}
int size = list.size();
byte[] b = new byte[size];
for (int i = 0; i < size; i++) {
b[i] = list.get(i);
}
return b;
}
/**
* 将一个 byte 转成一个二进制的字符串
*
* @param b 传入的 byte
* @param flag 标志是否需要补高位，如果是true，表示需要补高位，如果是false表示不补
* 如果是最后一个字节，无需补高位
* @return 是该 b 对应的二进制的字符串，（注意是按补码返回）
*/
private static String byteToString(boolean flag, byte b) {
//使用一个变量 保存 b
int temp = b;
/**
* 如果是正数，还存在补高位
* 按位与
*/
if (flag) {
temp |= 256;
}
String str = Integer.toBinaryString(temp);
System.out.println(str);
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
/**
* 使用一个方法，将前面的方法封闭起来，便于调用
*
* @param bytes 原始字符串对应的字节数组
* @return 是经过 赫夫曼编码处理后的字节数组（压缩后的数组）
*/
public static byte[] huffmanZip(byte[] bytes) {
List<Node> nodes = getNodes(bytes);
Node huffmanTree = createHuffmanTree(nodes);
Map<Byte, String> codes = getCodes(huffmanTree);
return zip(bytes, codes);
}
/**
* 编写一个方法，将一个字符串对应的 byte[] 数组，能过生成的赫夫曼编码表
* 返回一个赫夫曼编压缩后的 byte[] 数组
*
* @param bytes 原始的字符串对应的 byte[]
* @param huffmanCodes 生成赫夫曼编码 map
* @return 返回赫夫曼编码处理后的数组
* "i like like like java do you like a java"; => byte[] contentBytes
* => 对应的 byte[] huffmanCodeBytes , 即 8 位对应一个 byte，放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000（补码） => byte [推导 10101000 =》 10101000 - 1 =》 10100111（反码） =》11011000 = -88 ]
*/
public static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
//1. 利用 huffmanCodes 将 bytes 转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
System.out.println(stringBuilder);
/**
* 统计返回 byte[] huffmanCodeBytes 长度
* 一句话写完：
* int len = (stringBuilder.length() + 7 ) / 8;
* 举例：
* 假如 stringBuilder.length() == 9
* (9 + 7) / 8 依然等于 2
*/
int len;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
//创建存储压缩后的 byte 数组
byte[] huffmanCodeBytes = new byte[len];
//记录第几个 byte
int index = 0;
//因为每8位对应一个 byte ，所以步长 + 8
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 ，放入到
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
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;
}
/**
* 生成赫夫曼树对应的赫夫曼编码
* 思路：
* 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}
* <p>
* 2. 在生成赫夫编码表时，需要去拼接路径，定义一个 StringBulder 存储叶子
* 节点的路径
*/
static Map<Byte, String> huffmanCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的 node 节点的所有叶子结点的赫夫曼编码得到，并放入到
* huffmanCodes 集合中
*
* @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);
//如果 node == null 不处理
if (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("树为空，无法遍历");
}
}
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
//取出第一颗最小的二叉树
Node left = nodes.get(0);
//取出第二颗最小的二叉树
Node right = nodes.get(1);
/**
* 创建一颗二叉树
* 它的根节点，没有data，只有权值
*/
Node root = new Node(null, left.weight + right.weight);
root.left = left;
root.right = right;
//将处理过的两颗二叉树移除
nodes.remove(left);
nodes.remove(right);
nodes.add(root);
}
return nodes.get(0);
}
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//存储每个 byte 出现的次数
Map<Byte, Integer> map = new HashMap<>();
for (byte b : bytes) {
//如果有这个 key 表示已经存在了，将次数 ++
if (map.containsKey(b)) {
Integer value = map.get(b);
map.put(b, ++value);
} else {
map.put(b, 1);
}
}
for (Map.Entry<Byte, Integer> entry : map.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
}
/**
* 创建 Node，有数据和权值
*/
class Node implements Comparable<Node> {
/**
* 存储数据本身，比如 a = 97 空格 = 32
*/
Byte data;
/**
* 权值
* 表示字符出现的次数
*/
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
}
124 使用赫夫曼编码压缩文件
新增的文件
/**
*
* @param srcFile 你传入的希望压缩文件的全路径
* @param dstFile 将压缩文件放入的目录
*/
public static void zipFile(String srcFile, String dstFile){
try (
//创建文件输入流
FileInputStream is = new FileInputStream(srcFile);
//创建文件的一个输出流，存放压缩文件
OutputStream os = new FileOutputStream(dstFile);
//创建一个和文件输出流关联的ObjectOutPutStream
ObjectOutputStream oos = new ObjectOutputStream(os)
){
//创建一个和源文件大小一样的 byte 数组
byte[] b = new byte[is.available()];
//读取文件
is.read(b);
//获取到文件对应的赫夫曼编码表
byte[] huffmanBytes = huffmanZip(b);
//这里以对象流的方式定稿 赫夫曼编码，为了恢复源文件使用
oos.writeObject(huffmanBytes);
//注意一定要把赫夫曼编码写入压缩文件
oos.writeObject(huffmanCodes);
}catch (IOException e){
e.printStackTrace();
}
}
package com.old.Tree.huffmanCode_118;
import java.io.*;
import java.util.*;
public class HuffmanCodeDemo {
public static void main(String[] args) {
/*String strByte = "10101000";
System.out.println((byte) Integer.parseInt(strByte, 2));
String content = "i like like like java do you like a java";
byte[] contentBytes = content.getBytes();
System.out.println(contentBytes.length);
byte[] huffmanCodeBytes = huffmanZip(contentBytes);
System.out.println("编码过后长度：" + huffmanCodeBytes.length);
System.out.println("编码过后：" + Arrays.toString(huffmanCodeBytes));
System.out.println("解码：");
byteToString(false, (byte) 1);
byte[] sourceBytes = decode(huffmanCodes, huffmanCodeBytes);
System.out.println(sourceBytes.length);
System.out.println(new String(sourceBytes));*/
/**
List<Node> nodes = getNodes(contentBytes);
System.out.println(nodes);
//创建的二叉树
System.out.println("赫夫曼树：");
Node huffmanTree = createHuffmanTree(nodes);
preOrder(huffmanTree);
//测试是否生成了对应的赫夫曼树
getCodes(huffmanTree);
System.out.println(huffmanCodes);
byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
System.out.println("编码过后长度：" + huffmanCodeBytes.length);
System.out.println("编码过后：" + Arrays.toString(huffmanCodeBytes));
*/
String srcFile = "C:\\Users\\10420\\Desktop\\xmind\\temp\\t.txt";
String dstFile = "C:\\Users\\10420\\Desktop\\xmind\\temp\\t2.zip";
zipFile(srcFile, dstFile);
}
//编写方法，将一个文件进行压缩
/**
*
* @param srcFile 你传入的希望压缩文件的全路径
* @param dstFile 将压缩文件放入的目录
*/
public static void zipFile(String srcFile, String dstFile){
try (
//创建文件输入流
FileInputStream is = new FileInputStream(srcFile);
//创建文件的一个输出流，存放压缩文件
OutputStream os = new FileOutputStream(dstFile);
//创建一个和文件输出流关联的ObjectOutPutStream
ObjectOutputStream oos = new ObjectOutputStream(os)
){
//创建一个和源文件大小一样的 byte 数组
byte[] b = new byte[is.available()];
//读取文件
is.read(b);
//获取到文件对应的赫夫曼编码表
byte[] huffmanBytes = huffmanZip(b);
//这里以对象流的方式定稿 赫夫曼编码，为了恢复源文件使用
oos.writeObject(huffmanBytes);
//注意一定要把赫夫曼编码写入压缩文件
oos.writeObject(huffmanCodes);
}catch (IOException e){
e.printStackTrace();
}
}
/**
* 完成数据的解压
* 1. 将 huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
* 转成：赫夫曼编码对应的二进制字符串，1010100010111111110010001011111111001000101
* 2. 赫夫曼编码对应的二进制的字符串 "1010100010111111110" 对照赫曼编码 转为文字
*/
/**
* 编写一个方法，完成对压缩数据的解码
*
* @param huffmanCodes 赫夫曼编码表 map
* @param huffmanBytes 赫夫曼编码得到的字节数组
* @return 就是原来的字符串对应的数组
*/
private static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
//1. 先得到 huffmanBytes 对应的二进制的字符串，形式 1010100010111111110
StringBuilder stringBuilder = new StringBuilder();
//将 byte 数组转成二进制的字符串
for (int i = 0; i < huffmanBytes.length; i++) {
boolean flag = (i == huffmanBytes.length - 1);
String s = byteToString(!flag, huffmanBytes[i]);
stringBuilder.append(s);
}
System.out.println("赫夫曼字节数组对应的二进制字符串：");
System.out.println(stringBuilder);
//把字符串按照指定的赫夫曼编码进行解码
//把赫夫曼编码表进行调换，因为反射查的 97 -》 100 100-》？
Map<String, Byte> map = new HashMap<>();
for (Map.Entry<Byte, String> entry : huffmanCodes.entrySet()) {
map.put(entry.getValue(), entry.getKey());
}
System.out.println(map);
//创建集合，存入 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) {
/**
* 取出一个字符串. i 不动，让 count 移动，指定匹配到一个字符
*
*/
String key = stringBuilder.substring(i, i + count);
b = map.get(key);
if (b == null) {
/**
* 说明没有匹配到
*
*/
count++;
} else {
//匹配到
flag = false;
}
}
list.add(b);
/**
* 让 i 直接移动到 count 的位置
* 是因为上面一直在截取字符串，利用 count 不停的 ++ 截取
* 当截取到了，就会跳出循环，而此时说明 从 i 到 count 的
* 都是已经匹配的，所以这里让 i 直接 + = count
* 不是 直接 = 是因为 上面没有给 count 重新赋值
*
*/
i += count;
}
int size = list.size();
byte[] b = new byte[size];
for (int i = 0; i < size; i++) {
b[i] = list.get(i);
}
return b;
}
/**
* 将一个 byte 转成一个二进制的字符串
*
* @param b 传入的 byte
* @param flag 标志是否需要补高位，如果是true，表示需要补高位，如果是false表示不补
* 如果是最后一个字节，无需补高位
* @return 是该 b 对应的二进制的字符串，（注意是按补码返回）
*/
private static String byteToString(boolean flag, byte b) {
//使用一个变量 保存 b
int temp = b;
/**
* 如果是正数，还存在补高位
* 按位与
*/
if (flag) {
temp |= 256;
}
String str = Integer.toBinaryString(temp);
System.out.println(str);
if (flag) {
return str.substring(str.length() - 8);
} else {
return str;
}
}
/**
* 使用一个方法，将前面的方法封闭起来，便于调用
*
* @param bytes 原始字符串对应的字节数组
* @return 是经过 赫夫曼编码处理后的字节数组（压缩后的数组）
*/
public static byte[] huffmanZip(byte[] bytes) {
List<Node> nodes = getNodes(bytes);
Node huffmanTree = createHuffmanTree(nodes);
Map<Byte, String> codes = getCodes(huffmanTree);
return zip(bytes, codes);
}
/**
* 编写一个方法，将一个字符串对应的 byte[] 数组，能过生成的赫夫曼编码表
* 返回一个赫夫曼编压缩后的 byte[] 数组
*
* @param bytes 原始的字符串对应的 byte[]
* @param huffmanCodes 生成赫夫曼编码 map
* @return 返回赫夫曼编码处理后的数组
* "i like like like java do you like a java"; => byte[] contentBytes
* => 对应的 byte[] huffmanCodeBytes , 即 8 位对应一个 byte，放入到 huffmanCodeBytes
* huffmanCodeBytes[0] = 10101000（补码） => byte [推导 10101000 =》 10101000 - 1 =》 10100111（反码） =》11011000 = -88 ]
*/
public static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
//1. 利用 huffmanCodes 将 bytes 转成赫夫曼编码对应的字符串
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes) {
stringBuilder.append(huffmanCodes.get(b));
}
System.out.println(stringBuilder);
/**
* 统计返回 byte[] huffmanCodeBytes 长度
* 一句话写完：
* int len = (stringBuilder.length() + 7 ) / 8;
* 举例：
* 假如 stringBuilder.length() == 9
* (9 + 7) / 8 依然等于 2
*/
int len;
if (stringBuilder.length() % 8 == 0) {
len = stringBuilder.length() / 8;
} else {
len = stringBuilder.length() / 8 + 1;
}
//创建存储压缩后的 byte 数组
byte[] huffmanCodeBytes = new byte[len];
//记录第几个 byte
int index = 0;
//因为每8位对应一个 byte ，所以步长 + 8
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 ，放入到
huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
index++;
}
return huffmanCodeBytes;
}
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;
}
/**
* 生成赫夫曼树对应的赫夫曼编码
* 思路：
* 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}
* <p>
* 2. 在生成赫夫编码表时，需要去拼接路径，定义一个 StringBulder 存储叶子
* 节点的路径
*/
static Map<Byte, String> huffmanCodes = new HashMap<>();
static StringBuilder stringBuilder = new StringBuilder();
/**
* 功能：将传入的 node 节点的所有叶子结点的赫夫曼编码得到，并放入到
* huffmanCodes 集合中
*
* @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);
//如果 node == null 不处理
if (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("树为空，无法遍历");
}
}
private static Node createHuffmanTree(List<Node> nodes) {
while (nodes.size() > 1) {
Collections.sort(nodes);
//取出第一颗最小的二叉树
Node left = nodes.get(0);
//取出第二颗最小的二叉树
Node right = nodes.get(1);
/**
* 创建一颗二叉树
* 它的根节点，没有data，只有权值
*/
Node root = new Node(null, left.weight + right.weight);
root.left = left;
root.right = right;
//将处理过的两颗二叉树移除
nodes.remove(left);
nodes.remove(right);
nodes.add(root);
}
return nodes.get(0);
}
private static List<Node> getNodes(byte[] bytes) {
List<Node> nodes = new ArrayList<>();
//存储每个 byte 出现的次数
Map<Byte, Integer> map = new HashMap<>();
for (byte b : bytes) {
//如果有这个 key 表示已经存在了，将次数 ++
if (map.containsKey(b)) {
Integer value = map.get(b);
map.put(b, ++value);
} else {
map.put(b, 1);
}
}
for (Map.Entry<Byte, Integer> entry : map.entrySet()) {
nodes.add(new Node(entry.getKey(), entry.getValue()));
}
return nodes;
}
}
/**
* 创建 Node，有数据和权值
*/
class Node implements Comparable<Node> {
/**
* 存储数据本身，比如 a = 97 空格 = 32
*/
Byte data;
/**
* 权值
* 表示字符出现的次数
*/
int weight;
Node left;
Node right;
public Node(Byte data, int weight) {
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", weight=" + weight +
'}';
}
@Override
public int compareTo(Node o) {
//从小到大排序
return this.weight - o.weight;
}
public void preOrder() {
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
}
125 使用赫夫曼编码解压文件
思路:
读取压缩文件（数据和赫夫曼编码表）-》完成解压（文件恢复）
解压有问题，代码上要么报空指针，要么报数组越界，或是最终解压出来后乱码
报错的代码在 decode 方法中
解压方法
/**
* 压缩文件的解压
*
* @param zipFile 准备解压的文件
* @param dstFile 压缩后的文件
*/
public static void unZipFile(String zipFile, String dstFile) {
try (
//创建文件输入流
FileInputStream is = new FileInputStream(zipFile);
ObjectInputStream ois = new ObjectInputStream(is);
//创建文件的一个输出流，存放压缩文件
OutputStream os = new FileOutputStream(dstFile);
//创建一个和文件输出流关联的ObjectOutPutStream
) {
//创建一个和源文件大小一样的 byte 数组
byte[] b = new byte[ois.available()];
//读取文件
is.read(b);
//读取byte 数据
byte[] huffmanBytes = (byte[]) ois.readObject();
Map<Byte, String> huffmanCoes = (Map<Byte, String>) ois.readObject();
//解码
byte[] bytes = decode(huffmanCoes, huffmanBytes);
os.write(bytes);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
126 赫夫曼编码的注意事项
注意事项
- 如果文件本身是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化，比如视频，ppt等等文件
- 赫夫曼编码是按字节来处理的，因此可以处理所有的文件（二进制文件，文本文件）
- 如果一个文件中的内容，重复的数据不多，压缩效果也不会很显示
1040
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
