Introducción al período fundacional
El período de creación de cimientos describe principalmente los principios necesarios para la compresión y descompresión, principalmente la descripción del texto y una pequeña cantidad de análisis de imágenes.
Proporcione el código completo, puede usar el espacio de blogger directamente sin aprender
https://blog.csdn.net/JOElib?spm=1011.2266.3001.5343Algoritmo de búsqueda de Qianggehttps:
Visión general de la definición
sendero
sendero
La ruta es cómo llegar desde el nodo raíz al nodo de destino, y el proceso en el medio se llama la ruta.
la longitud del camino
La longitud de la ruta es el número de nodos experimentados en medio del proceso de caminar. Por ejemplo, la longitud de la ruta del nodo en la capa Lth es L-1.
peso del nodo
El peso de un nodo es un número al que se le asigna un significado especial en el nodo, y este número se denomina peso del nodo.
longitud de ruta ponderada
El peso del nodo se multiplica por el tamaño de la ruta del nodo, y el producto se denomina ruta ponderada.
longitud de ruta ponderada del árbol
La ruta ponderada del árbol representa la suma de las rutas ponderadas de todos los nodos hoja y se denomina ruta ponderada del árbol. La abreviatura de la ruta ponderada del árbol es WPL
árbol de huffman
El árbol de Huffman es un tipo especial de árbol binario. Este árbol binario tiene el WPL más pequeño, es decir, el árbol binario con la ruta ponderada más pequeña del árbol se llama árbol de Huffman. Su característica es que cuanto mayor es el peso, más cerca está el el nodo es.
método de almacenamiento
Codificación de longitud fija
Tomando como ejemplo una cadena, según el complemento a dos correspondiente al código ASCII de cada carácter, se almacena intacta, lo que se denomina codificación de longitud fija.
codificación de longitud variable
Tomando una cadena como ejemplo, primero cuente la cantidad de elementos que aparecen en cada carácter, clasifíquelos primero y, de acuerdo con el orden de clasificación, escriba un código binario más pequeño para el ASCII más grande y use estos códigos para almacenar
Desventaja: La lectura del código producirá discrepancias, como códigos 01 y 011, sus dos prefijos son iguales y se leen uno por uno, supongamos que queremos 011, el sistema puede leer 01
codificación de prefijo
Codificación de prefijo, es decir, el prefijo de cada codificación de longitud variable es diferente, lo que puede evitar las deficiencias de divergencia en la lectura mencionadas anteriormente
Codificación Huffman
La codificación Huffman es una codificación de prefijo especial, y la codificación Huffman correspondiente se obtiene de acuerdo con la ruta
código completo
package datastructure.chapter04.tree.huffman.huffmancoding;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 江骏杰
* Date: 2022-03-29
* Time: 21:38
*/
public class Node implements Comparable<Node> {
public Byte ascii;
public int value;
public Node left;
public Node right;
public Node(Byte ascii,int value) {
this.ascii = ascii;
this.value = value;
}
public String toString() {
return "Node[ascii = " + ascii + " value = " + value + "]";
}
public int compareTo(Node node) {
return value - node.value;
}
}
package datastructure.chapter04.tree.huffman.huffmancoding;
import java.io.*;
import java.util.*;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 江骏杰
* Date: 2022-03-29
* Time: 21:37
*/
public class HuffmanCode implements Serializable {
@Serial
private static final long serialVersionUID = 4420;
private static final HashMap<Byte,String> HUFFMAN_CODES = new HashMap<>();
private static final StringBuffer STRING_BUFFER = new StringBuffer();
private static int lastCount;
public static byte[] huffmanCodeZip(String s) {
var content = s.getBytes();
var list = getNodes(content);
var huffmanTreeRoot = createHuffmanTree(list);
getCodes(huffmanTreeRoot,"",STRING_BUFFER);
return zip(content,HUFFMAN_CODES);
}
public static byte[] huffmanCodeZip(byte[] content) {
var list = getNodes(content);
var huffmanTreeRoot = createHuffmanTree(list);
getCodes(huffmanTreeRoot,"",STRING_BUFFER);
return zip(content,HUFFMAN_CODES);
}
public static List<Node> getNodes(byte[] content) {
var map = new HashMap<Byte,Integer>();
var list = new ArrayList<Node>();
for (var item : content) {
var count = map.get(item);
if (count == null) {
map.put(item,1);
}else {
map.put(item,++count);
}
}
for (var entry : map.entrySet()) {
list.add(new Node(entry.getKey(),entry.getValue()));
}
return list;
}
public static Node createHuffmanTree(List<Node> list) {
while (list.size() > 1) {
Collections.sort(list);
var leftNode = list.get(0);
var rightNode = list.get(1);
var parentNode = new Node(null, leftNode.value + rightNode.value);
parentNode.left = leftNode;
parentNode.right = rightNode;
list.add(parentNode);
list.remove(1);
list.remove(0);
}
return list.get(0);
}
public static void getCodes(Node node,String code,StringBuffer strBuf) {
var curStrBuf = new StringBuffer(strBuf);
curStrBuf.append(code);
if (node != null) {
if (node.ascii == null) {
getCodes(node.left,"0",curStrBuf);
getCodes(node.right,"1",curStrBuf);
}else {
HUFFMAN_CODES.put(node.ascii,curStrBuf.toString());
}
}
}
public static byte[] zip(byte[] content,Map<Byte,String> huffmanCodes) {
var strBuf = new StringBuilder();
for (var item : content) {
strBuf.append(huffmanCodes.get(item));
}
var len = (strBuf.length() + 7) / 8;
var huffmanCodesBytes = new byte[len];
String str;
var index = 0;
for (int i = 0; i < strBuf.length(); i+= 8) {
if (i + 8 < strBuf.length()) {
str = strBuf.substring(i,i+8);
}else {
str = strBuf.substring(i);
lastCount = str.length();
}
huffmanCodesBytes[index++] = (byte) Integer.parseInt(str,2);
}
return huffmanCodesBytes;
}
public static String byteToString(byte b,boolean flag) {
int temp = b;
temp |= 256;
String str = Integer.toBinaryString(temp);
if (flag) {
return str.substring(str.length() - 8);
}
return str.substring(str.length() - lastCount);
}
public static byte[] decode(byte[] huffmanCodesBytes,Map<Byte,String> huffmanCodes) {
var strBil = new StringBuilder();
for (int i = 0; i < huffmanCodesBytes.length; i++) {
boolean flag = (i != huffmanCodesBytes.length -1);
strBil.append(byteToString(huffmanCodesBytes[i],flag));
}
var map = new HashMap<String,Byte>();
for (var entry : huffmanCodes.entrySet()) {
map.put(entry.getValue(),entry.getKey());
}
var list = new ArrayList<Byte>();
for (int i = 0; i < strBil.length();) {
Byte b ;
var count = 1;
while ((b = map.get(strBil.substring(i, i + count))) == null) {
count++;
}
list.add(b);
i += count;
}
var content = new byte[list.size()];
for (int i = 0; i < content.length; i++) {
content[i] =list.get(i);
}
return content;
}
public static String decode(byte[] huffmanBytes) {
return new String(decode(huffmanBytes,HUFFMAN_CODES));
}
public static void fileZip(String srcPath,String desPath) {
try(var fis = new FileInputStream(srcPath);
var fos = new FileOutputStream(desPath);
var oos = new ObjectOutputStream(fos)
) {
var content = new byte[fis.available()];
fis.read(content);
byte[] huffmanBytes = huffmanCodeZip(content);
oos.writeObject(huffmanBytes);
oos.writeObject(HUFFMAN_CODES);
oos.writeObject(lastCount);
oos.flush();
fos.flush();
}catch (Exception e) {
e.printStackTrace();
}
}
public static void fileDeZip(String zipPath,String desPath) {
try(var fis = new FileInputStream(zipPath);
var ois = new ObjectInputStream(fis);
var fos = new FileOutputStream(desPath)
) {
var huffmanBytes = (byte[])ois.readObject();
var huffmanCodes = (Map<Byte,String >)ois.readObject();
lastCount = (int)ois.readObject();
var content = decode(huffmanBytes,huffmanCodes);
fos.write(content);
fos.flush();
}catch (Exception e) {
e.printStackTrace();
}
}
}
En conclusión
Para completar un código, primero debemos entender su principio. A través de este principio, podemos espiar a uno o dos
En el próximo artículo, comenzaremos a crear árboles de Huffman.