哈夫曼编码与解码

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);
        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();
    }
}