哈夫曼编码

哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。

哈夫曼编码步骤：

一、对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算 法，一般还要求以Ti的权值Wi的升序排列。）
二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。
三、从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。
四、重复二和三两步，直到集合F中只有一棵二叉树为止。

比如字符串 abbccc；那么计算机中存储的应该是01100001（a）01100001（a）01100010 （b）01100010 （b）01100011 （c）01100011 （c）01100011 （c），一共占6个字节；

现在利用哈夫曼树将这个文件进行编码

将每个字出现的次数作为权值来构造哈夫曼树，上面的字符串中a出现了1次，b出现了2次，c 出现了2次，那这三个字符的权重分别为 1,2,3  那么我们得到的哈夫曼树如下图：

如上图，三个字符的哈夫曼编码为：  a: 00   b: 01   c: 1

原来的编码：abbccc => 01100001 01100001 01100010 01100010 01100011 01100011 01100011 

现在的哈夫曼编码：abbccc => 00 01 01 1 1 1 

 

原来的6个字节现在变成了不到 2个字节了；我们只要把这个新的01串转成十进制整数，再把这个十进制的整数写入到压缩文件中即完成了压缩；

 

Java代码如下：

/**
 * 哈夫曼树的节点
 */
public class Node implements Comparable<Node> {

    private char c = 0; // 以16位为单元的字符
    private int weight = 0; // 字符出现的次数
    private Node left = null;
    private Node right = null;

    public Node() {
    }

    public Node(char c, int weight) {
        this.c = c;
        this.weight = weight;
    }

    public char getC() {
        return c;
    }

    public void setC(char c) {
        this.c = c;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public int compareTo(Node o) {
        return this.weight - o.getWeight();
    }

}

 

public class HuffmanAlgorithm  {
 
    public EncodeResult encode(String str) {
        List<Node> letterList = toList(str);
        Node rootNode = createTree(letterList);
        Map<Character, String> letterCode = getLetterCode(rootNode);
        EncodeResult result = encode(letterCode, str);
        return result;
    }

    /**
     * 把一个字符串转化为节点列表
     * 
     * @param letters
     * @return
     */
    private List<Node> toList(String letters) {

        Map<Character, Integer> charMap = new HashMap<Character, Integer>();
        for (int i = 0; i < letters.length(); i++) {
            Character character = letters.charAt(i);
            if (!charMap.containsKey(character)) {
                charMap.put(character, 1);
            } else {
                Integer oldValue = charMap.get(character);
                charMap.put(character, oldValue + 1);
            }
        }

        return charMap.entrySet().stream().map(entry -> {
            return new Node(entry.getKey(), entry.getValue());
        }).collect(Collectors.toList());
    }

    protected Node createTree(List<Node> letterList) {
        int n = letterList.size();

        PriorityQueue<Node> queue = new PriorityQueue<Node>(n);
        for (Node node : letterList) {
            queue.add(node);
        }
        // 需要n-1步
        for (int i = 1; i <= n - 1; i++) {
            Node left = queue.poll();
            Node right = queue.poll();
            Node parent = new Node();

            parent.setWeight(left.getWeight() + right.getWeight());
            parent.setLeft(left);
            parent.setRight(right);
            queue.add(parent);
        }
        return queue.poll();
    }

    /**
     * 编码字符串。
     * 
     * @param letterCode
     *            字符/编码对集合(编码器： 如： a -> 01)
     * @param letters
     *            指定的需要编码的字符串。
     * @return 编码结果
     */
    private EncodeResult encode(Map<Character, String> letterCode, String letters) {
        StringBuilder encode = new StringBuilder();
        for (int i = 0, length = letters.length(); i < length; i++) {
            Character character = letters.charAt(i);
            encode.append(letterCode.get(character));
        }
        EncodeResult result = new EncodeResult(encode.toString(), letterCode);
        return result;
    }

    /**
     * 获得所有字符编码对
     * 
     * @param rootNode哈夫曼树的根节点
     * @return 所有字符编码对
     */
    private Map<Character, String> getLetterCode(Node rootNode) {
        Map<Character, String> letterCode = new HashMap<Character, String>();
        // 处理只有一个节点的情况
        if (rootNode.getLeft() == null && rootNode.getRight() == null) {
            letterCode.put(rootNode.getC(), "1");
            return letterCode;
        }

        getLetterCode(rootNode, "", letterCode);
        return letterCode;
    }

    /**
     * 先序遍历哈夫曼树,获得所有字符编码对。
     * 
     * @param rooNode
     *            哈夫曼树根结点
     * @param suffix
     *            编码前缀，也就是编码这个字符时，之前路径上的所有编码
     * @param letterCode
     *            用于保存字符编码结果
     */
    private void getLetterCode(Node rooNode, String suffix, Map<Character, String> letterCode) {
        if (rooNode != null) {
            if (rooNode.getLeft() == null && rooNode.getRight() == null) {
                letterCode.put(rooNode.getC(), suffix); // 到根节点了，把编码加上(字符->哈夫曼编码对应)
            }
            getLetterCode(rooNode.getLeft(), suffix + "0", letterCode);
            getLetterCode(rooNode.getRight(), suffix + "1", letterCode);
        }
    }

    public String decode(EncodeResult decodeResult) {
        StringBuffer decodeStr = new StringBuffer();
        
        Map<String, Character> decodeMap = getDecoder(decodeResult.getLetterCode()); // 获得解码器
        // 待解码的（被编码的）字符串
        String encode = decodeResult.getEncode();
        // 从最短的开始匹配之所以能够成功，是因为哈夫曼编码的唯一前缀性质
        // 临时的可能的键值
        String temp = "";
        // 改变temp值大小的游标
        int i = 1;
        while (encode.length() > 0) {
            temp = encode.substring(0, i);
            if (decodeMap.containsKey(temp)) {
                Character character = decodeMap.get(temp);
                decodeStr.append(character);
                encode = encode.substring(i);
                i = 1;
            } else {
                i++;
            }
        }
        return decodeStr.toString();
    }

    /**
     * 获得解码器，也就是通过字母/编码对得到编码/字符对。
     * 
     * @param letterCode
     * @return
     */
    private Map<String, Character> getDecoder(Map<Character, String> letterCode) {
        Map<String, Character> decodeMap = new HashMap<String, Character>();
        Set<Character> keys = letterCode.keySet();
        for (Character key : keys) {
            String value = letterCode.get(key);
            decodeMap.put(value, key);
        }
        return decodeMap;
    }
}

/**
 * 对字符串编码后的结果：包括编码后的字符串和字符/编码对
 */
public class EncodeResult {
    // 字符串编码后的结果
    private String encode;
    // 字符编码对
    private Map<Character, String> letterCode;

    public EncodeResult(String encode, Map<Character, String> letterCode) {
        this.encode = encode;
        this.letterCode = letterCode;
    }

    public String getEncode() {
        return encode;
    }

    public Map<Character, String> getLetterCode() {
        return letterCode;
    }
}