En primer lugar, mirar lo que es árbol de Huffman:
Dado n pesos como los n nodos de hoja , una configuración de árbol binario, si la longitud de camino ponderado del árbol alcanza un mínimo, tal árbol binario se llama óptima árbol binario, también conocido como Huffman árbol (Huffman Tree). árbol de Huffman es el más corto árbol ponderado longitud del camino, es decir, mayor peso desde el nodo raíz más cerca.
árbol de Huffman, también conocido como árbol binario óptimo, es un camino correcto con la longitud más corta de un árbol binario . longitud de trayectoria ponderada de la llamada árbol, el árbol es el peso de todos los nodos de la hoja de la longitud del camino multiplicado por el valor al que el nodo raíz (si el nodo raíz de la capa 0, el nodo raíz al nodo hoja es una longitud de la trayectoria de la hoja capas Junction puntos). Es la longitud de la trayectoria de la ruta desde la raíz del árbol a cada nodo y la longitud, denotado por WPL = (W1 * L1 + W2 * L2 + W3 * L3 + ... + Wn * Ln), N th pesos Wi ( i = 1,2, ... n) de N configuración binaria tiene un nodo de hoja, la longitud del camino del nodo hoja correspondiente es Li (i = 1,2, ... n ). WPL puede resultar árbol de Huffman es mínima.
Aquí hay algunos conceptos básicos sobre el árbol de Huffman:
1, la ruta y la longitud del camino
En un árbol, los caminos entre nodos de un niño puede alcanzar abajo o nodos nietos, llamados un camino. El número de ramas se llama una ruta de la longitud del camino. Si el número predeterminado de capas es un nodo raíz, la longitud del camino desde el nodo raíz a la primera capa de nodos L es L-1.
2, el nodo de la derecha y la longitud del camino ponderada
Si el nodo del árbol tiene un cierto valor asignado sentido, este valor se refiere como el nodo de la derecha. longitud de trayectoria ponderada para el nodo: el producto de la longitud del camino desde la raíz hacia la derecha entre el nodo del nodo.
3, el árbol de longitud de trayectoria ponderada
longitud de trayectoria ponderada se define como el árbol de la longitud de trayectoria ponderada y todos los nodos hoja, denotado] WPL, la forma óptima árbol binario no es único, la WPL mínimo.
estructura de árbol de Huffman
1) que constituye el n árboles binarios de acuerdo con un determinado n-pesos {w1, w2, w3, w4 ...... wn} Bosque F = {T1, T2, T3 ..... Tn}, donde cada uno árboles binarios solamente un nodo raíz de un peso de wi, los subárboles izquierdo y derecho están vacías;
2) Seleccionar el bosque F peso mínimo de dos nodo raíz del árbol binario, el árbol binario como un nuevo sub-estructuras izquierda y derecha para que el nodo raíz del árbol binario es que los nuevos pesos y la izquierda y subárbol derecho;
3) Eliminar el sub-árbol seleccionado de que dos F, y el nuevo binario que consiste en F añadido a bosque;
4) Repetir 2, 3 operación hasta que el bosque contiene solo árbol binario, en cuyo momento el árbol resultante es un árbol de Huffman binario.
árbol de Huffman se da a continuación la aplicación Java. (Hay algunos cambios con respecto a la original)
package gxu.wjb.tree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 哈夫曼树的构建
* @version 创建时间：2019-8-9 下午2:51:02
*
*
*/
public class HuffmanTree {
public static class Node<E> {
E data;
double weight;
Node<E> leftChild;
Node<E> rightChild;
public Node(E data, double weight) {
this.data = data;
this.weight = weight;
}
}
public static void main(String[] args) {
List<Node<String>> nodes = new ArrayList<Node<String>>();
nodes.add(new Node<String>("A", 40.0));
nodes.add(new Node<String>("B", 8.0));
nodes.add(new Node<String>("C", 10.0));
nodes.add(new Node<String>("D", 30.0));
nodes.add(new Node<String>("E", 10.0));
nodes.add(new Node<String>("F", 2.0));
Node<String> root = HuffmanTree.createTree(nodes);
breadthFirst(root);
}
public static Node<String> createTree(List<Node<String>> nodes) {
// 只要nodes列表中还有2个及以上的节点
while (nodes.size() > 1) {
quickSort(nodes, 0, nodes.size() - 1);
// 获取权值最小的两个点
Node<String> left = nodes.get(0);
Node<String> right = nodes.get(1);
// 生成新节点，新节点的权值为两个子节点权值之和
Node<String> parent = new Node<String>(null, left.weight
+ right.weight);
// 让新节点作为两个最小节点的父节点
parent.leftChild = left;
parent.rightChild = right;
// 删除两个最小节点
nodes.remove(0);
nodes.remove(0);
// 将新节点加入到集合中
nodes.add(parent);
}
// 剩余一个节点的时候返回即可
return nodes.get(0);
}
/**
* 实现快速排序算法，该快排是基于荷兰国旗的思想进行改进后的实现，用于对节点进行排序
*/
public static void quickSort(List<Node<String>> nodes, int L, int R) {
if (L < R) {
int[] p = getProcess(nodes, nodes.get(L), L, R);
quickSort(nodes, L, p[0] - 1);
quickSort(nodes, p[1], R);
}
}
private static int[] getProcess(List<Node<String>> nodes,
Node<String> base, int L, int R) {
int less = L - 1;
int more = R + 1;
int cur = L;
while (cur < more) {
if (nodes.get(cur).weight < base.weight) {
swap(nodes, ++less, cur++);
} else if (nodes.get(cur).weight == base.weight) {
cur++;
} else {
swap(nodes, --more, cur++);
}
}
return new int[] { less + 1, more };
}
/**
* 将指定集合中的i和j索引处的元素交换
*
* @param nodes
* @param i
* @param j
* @return
*/
private static void swap(List<Node<String>> nodes, int i, int j) {
Node<String> temp = nodes.get(i);
nodes.set(i, nodes.get(j));
nodes.set(j, temp);
}
// 广度优先遍历，也就是按层次遍历
public static void breadthFirst(Node<String> head) {
if (head == null) {
return;
}
Queue<Node<String>> queue = new LinkedList<Node<String>>();
queue.offer(head);
while (!queue.isEmpty()) {
head = queue.poll();
System.out.println(head.data);
if (head.leftChild != null) {
queue.offer(head.leftChild);
}
if (head.rightChild != null) {
queue.offer(head.rightChild);
}
}
}
}
codificación Huffman
De acuerdo con árbol de Huffman puede resolver el problema de codificación de mensajes. Suponga que desea una cadena, como "abcdabcaba" codificar, lo convierte en un código binario único, sino que requiere una longitud mínima de la conversión de código binario a cabo.
Supone que la frecuencia de W, que es la longitud del código es L, el n codificada caracteres, la longitud total del código binario codificado es W1L1 + W2L2 + ... + WnLn, lo que ocurre principios Huffman árbol para cada carácter en el aparece de cuerda . Así principio de construcción del árbol de Huffman binario de codificación puede ser empleado, de manera que la longitud del mensaje corto.
Por "abcdabcaba", un total de a, b, c, caracteres d4, número de ocurrencias 4,3,2,1 respectivamente, que corresponde a su peso, la a, b, c, d es el peso con el número de configuración de ocurrencias árbol de Huffman, la parte inferior izquierda de los resultados obtenidos.
A partir de la raíz nodo de Huffman, asignado al código subárbol izquierdo es "0" asigna "1" en el subárbol derecho hasta llegar a un nodo hoja. Huffman Luego, a partir de la raíz de los alcances de los árboles a los códigos nodo hoja se alinean a lo largo de cada camino, cada nodo hoja obtendrá de codificación, abajo a la derecha.
0
Como puede verse en la figura, a, b, c, d, respectivamente 0,10,110,111 correspondiente de codificación, a continuación, la cadena "abcdabcaba" en un código binario correspondiente es 0101101110101100100, una longitud de solamente 19. Esta es la codificación binaria más corto, también conocido como la codificación de Huffman.
