Criando uma árvore de Huffman é simples. 
Ordene esta lista por freqüência e faça os elementos mais duplo em folhas, enquanto criando um nodo de pai com uma freqüência que é a soma das freqüências do dois mais baixo elemento: 

12: * 
/ \ 
5:1 7:2 
Os dois elementos são afastados da lista e o nodo de pai novo, com freqüência 12, é inserida na lista por freqüência. 
Tão agora a lista, ordenada por freqüência, é: 
10:3 
12: * 
15:4 
20:5 
45:6 
Você repete a volta então, enquanto combinando os dois mais baixos elementos. Isto resulta dentro: 
22: * 
/ \ 
10:3 12: * 
/ \ 
5:1 7:2 
e a lista é agora: 
15:4 
20:5 
22: * 
45:6 
Você repete até lá é só um elemento partido na lista. 
35: * 
/ \ 
15:4 20:5 

22: * 
35: * 
45:6 

57: * 
___ / \___ 
/ \ 
22: * 35: * 
/ \ / \ 
10:3 12: * 15:4 20:5 
/ \ 
5:1 7:2 

45:6 
57: * 

102: * 
__________________ / \__ 
/ \ 
57: * 45:6 
___ / \___ 
/ \ 
22: * 35: * 
/ \ / \ 
10:3 12: * 15:4 20:5 
/ \ 
5:1 7:2 
Agora a lista é há pouco um elemento que contém 102: *, você é terminado. 
Este elemento se torna a raiz de sua árvore de huffman binária. Gerar um código de huffman você atravessa a árvore ao valor que você quer, saindo uns 0 toda vez você leva uma filial de esquerda, e um 1 toda vez você leva uma filial de direita. (normalmente você atravessa a árvore para trás do código você quer e constrói o huffman binário que codifica para trás como bem fio, desde que o primeiro pedaço tem que começar do topo). 

Exemplo: A codificação para o valor 4 (15:4) é 010. A codificação para o valor 6 (45:6) é 1 

Decodificando um huffman codificando é da mesma maneira que fácil: como você pedaços leram dentro de seu fluxo de contribuição você atravessa o começo de árvore à raiz, enquanto levando o caminho de mão esquerda se você lesse uns 0 e o caminho de mão direita se você lesse um 1. Quando você bateu uma folha, você achou o código. 

Geralmente, qualquer esquema de compressão de huffman também requer o huffman sobem em árvore para ser escritos fora como parte do arquivo, caso contrário o leitor não pode decodificar os dados. Para uma árvore estática, você não tem que fazer isto desde que a árvore é conhecida e fixa. 

O modo mais fácil para produção o huffman sobem em árvore é, enquanto começando à raiz, esvazie primeiro então o lado de mão esquerda o lado de mão direita. Para cada nodo você produção uns 0, para cada folha você produção um 1 seguida por pedaços de N que representam o valor. Por exemplo, a árvore parcial em meu último exemplo sobre usar 4 pedaços por valor pode ser representado como segue: 

000100 6 pedaço byte fixo indica quantos pedaços o valor 
para cada folha é armazenada dentro. Neste caso, 4. 
0 raiz é um nodo 
lado de mão esquerda é 
10011 uma folha com valor 3 
lado de mão direita é 
0 outro nodo 
recursivo abaixo, lado de mão esquerda é 
10001 uma folha com valor 1 
lado de mão direita é 
10010 uma folha com valor 2 
recursão devolvem 
Assim a árvore parcial pode ser representada com 00010001001101000110010, ou 23 pedaços. 

Não foi ruim!