哈夫曼编码与解码

package datastructure;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;

class HuffmanTree {
char data;
HuffmanTree left, right;
int frequency;
}

class HuffmanCoding{

public HuffmanTree buildHuffmanTree(char[] chars, int[] frequency){

Comparator<HuffmanTree> cmp = new Comparator<HuffmanTree>() {

@Override
public int compare(HuffmanTree o1, HuffmanTree o2) {
if(o1.frequency < o2.frequency)
return -1;
else if(o1.frequency > o2.frequency)
return 1;
else
return 0;
}

};
Queue<HuffmanTree> queue = new PriorityQueue<HuffmanTree>(100,cmp);
for(int i = 0; i < chars.length; i++){
HuffmanTree node = new HuffmanTree();
node.data = chars[i];
node.frequency = frequency[i];
node.left = node.right = null;
queue.add(node);
}
while(queue.size() > 1){
HuffmanTree min1 = queue.poll();
HuffmanTree min2 = queue.poll();
HuffmanTree newOne = new HuffmanTree();
newOne.data = '$';
newOne.frequency = min1.frequency + min2.frequency;
newOne.left = min1;
newOne.right = min2;
queue.add(newOne);
}
return queue.poll();
}
public void encode(HuffmanTree root, int[] codes, int level){
if(root.left != null){
codes[level] = 0;
encode(root.left, codes, level + 1);
}
if(root.right != null){
codes[level] = 1;
encode(root.right, codes, level + 1);
}
if(root.left == null && root.right == null){
System.out.print(root.data + "  ");
printCode(codes, level);
}
}
public void printCode(int[] codes, int level){
for(int i = 0; i < level; i++)
System.out.print(codes[i]);
System.out.println();
}

public String decode(HuffmanTree root, char[] str){
StringBuilder result = new StringBuilder();
HuffmanTree p = root;
for(int i = 0; i < str.length; i++){
if(str[i] == '0')
p = p.left;
else if(str[i] == '1')
p = p.right;
if(p.left == null && p.right == null){
result.append(p.data);
p = root;
}
}
if(p != root)
return null;
else
return result.toString();
}

public void encodeToMap(HuffmanTree root, int[] codes, int level, Map<Character, Integer[]> map){
if(root.left != null){
codes[level] = 0;
encodeToMap(root.left, codes, level + 1, map);
}
if(root.right != null){
codes[level] = 1;
encodeToMap(root.right, codes, level + 1, map);
}
if(root.left == null && root.right == null)
putCode(codes, level, map, root.data);
}
public void putCode(int[] codes, int level, Map<Character, Integer[]> map, char key){
Integer[] value = new Integer[level];
for(int i = 0; i < level; i++)
value[i] = codes[i];
map.put(key, value);
}
public void printMapCode(Integer[] printCodes){
for(int k = 0; k < printCodes.length; k++)
System.out.print(printCodes[k]);
System.out.println();
}

public void HuffmanCode(){
char[] chars = {'a', 'b', 'c', 'd', 'e', 'f'};
int[] frequency = {5, 9, 12, 13, 16, 45};
System.out.println("character and code-word :");
HuffmanTree tree =  buildHuffmanTree(chars, frequency);

4000
int[] codes = new int[100];
int level = 0;
//  encode(tree, codes, level);

Map<Character, Integer[]> map = new HashMap<Character, Integer[]>();
encodeToMap(tree, codes, level, map);
for(int i = 0; i < chars.length; i++){
System.out.print(chars[i] + " ");
printMapCode(map.get(chars[i]));
}

String str = "11001010011011101111";
String decodeResult = decode(tree, str.toCharArray());
if(decodeResult != null)
System.out.println("result = " + decodeResult);
else
System.out.println("decode error");
}
}
public class HuffmanCoding1 {

public static void main(String[] args) {
HuffmanCoding hc = new HuffmanCoding();
hc.HuffmanCode();
}
}