[数据结构] 2.2 Huffman树

注：本文原创，转载请注明出处，本人保留对未注明出处行为的责任追究。

1.Huffman树是什么

Huffman树也称为哈夫曼编码，是一种编码方式，常用于协议的制定，以节省传输空间。

A - F字母，出现的频率分别为:

A:5,B: 24, C:7,D:17,E:34,F:5,G:13

对比:

1)使用常规协议

如果我们将这些字母无论大小进行编码，一共是7个字母，因此协议规定用三位二进制数表示，传输完这105个字符，共需要105*3 = 315位。

2）使用Huffman树

如果我们按照Huffman树的规则（如上图），共需要 5*4 + 24 * 2 + 7*4 + 17*2 + 34*1+5*5+13*3 = 228位，共节省87位，大约节省27%的带宽占用。

2.Huffman树的原理

Huffman树是依据字符的出现频次，对字符进行二进制的编码，出现频次高的节点编码字符少，出现频次低的字节编码字符多。

感谢: https://www.cnblogs.com/journal-of-xjx/p/6670464.html 博主:Jiaxin Tse

如图是huffman树的构建过程，字符的权重为出现频次。

构建过程:

　　STEP1:将权重最小的两个字符节点构建一个父节点，权重为两者权重之和

　　STEP1 进行 size - 1次 ，即可完成huffman树的构建。

编码过程: 给定字符串，以及"单词-频次Map" ，构建huffman树，将给定字符串转成二进制字符串

　　以字符d为例子，从根节点开始，右枝为1，左枝为0，因此d的编码就是111

　　给定 abdc  => 0101111100

　　因为每一个被编码的字符节点是叶子节点，因此每一串二进制编码都有唯一对应的译码

解码过程: 给定二进制编码，以及"单词-频次Map",构建huffman树，将给定的二进制字符串转成字符串

　　0101111100 => abdc

　　

3.Huffman树的三大操作

Huffman树常见的三大操作有 构建、编码、解码。上面给出了一些基本原理和使用，接下来是代码设计的思路。

Node 以及Tree :

/**
 * 哈夫曼树
 */
public class HuffmanTree {
    static class Node{
        Character ch; // 保存被编码的字符
        long frequency ; // 被编码的字符出现频次
        Node left; // 左子节点
        Node right; // 右子节点
        Node parent; // 父节点
    }

static class Tree{
    Node root;
    List<Node> leafNodes;
}

1）构建huffman树

STEP1: 将每个字符抽象成一个节点，使用PriprotiesQueue这种排序的结构，按照Node的权值，也就是单词的出现频次为优先级排序

STEP2: 取出其中权值最小的两个节点，进行构建父节点，父节点权值为子节点权值之和。

　　      假设初始的节点数(初始的队列大小)为size,那么需要size - 1次STEP2才能完成整颗huffman树的构建。

　　　  记得存储叶子节点的列表，以便编码的时候能从叶子节点向根节点进行拼接字符串。

/**
 * 构建huffman树
 * @return
 */
public static Tree buildHuffmanTree(
        Map<Character,Long>  charAndCounts){

    Tree huffmanTree = new Tree();
    huffmanTree.leafNodes = new ArrayList<Node>();
    // 依据Node有序的队列
    PriorityQueue<Node> priorityQueue = new PriorityQueue<Node>();

    // 对每个字符进行遍历
    for(Character ch : charAndCounts.keySet()){
        long frequency = charAndCounts.get(ch);
        Node node = new Node(ch,frequency);
        // 存入叶子节点列表，以便于遍历
        huffmanTree.leafNodes.add(node);
        // 入堆
        priorityQueue.add(node);
    }

    // 进行建树操作，进行size-1次操作，每次取出两个最小的权值的节点，构建父节点并合并权值。
    for(int i = 0 ; i < charAndCounts.size() - 1 ; i++ ){
        Node node1 = priorityQueue.poll(); // 第一小 ，默认放右边
        Node node2 = priorityQueue.poll(); // 第二小，默认放左边
        Node top = new Node();
        top.right = node1;
        top.left = node2;
        top.frequency = node1.frequency + node2.frequency;

        node1.parent = top;
        node2.parent = top;

        priorityQueue.add(top);
    }

    // 经过size-1次合并操作后，队列中只剩下一个节点
    huffmanTree.root = priorityQueue.poll();
    return huffmanTree;
}

2）编码 : 给定字符串，以及"单词-频次Map" ，构建huffman树，将给定字符串转成二进制字符串

首先使用 "单词-频次"Map 构建huffman树。

依次遍历每个huffman树的叶子节点，每个节点由叶子节点向根节点遍历，并进行 0 、1的拼接。

这样就生成了 Map<字符，二进制编码>表。

然后依次遍历给定字符串的每个字符，分别转成二进制编码拼接即可。

   /**
     * 进行编码
     * @param str
     * @param charAndCounts
     * @return
     */
    public static String encode(
            String str,
            Map<Character,Long> charAndCounts){
        Map<Character,String> chAndEncoding = new HashMap<Character, String>();
        // 1. 构建huffman树
        Tree tree = buildHuffmanTree(charAndCounts);
        // 2.依次遍历每个huffman树的叶子节点，每个节点由叶子节点向根节点遍历，并进行 0 、1的拼接。
        List<Node> leafNodes = tree.leafNodes;
        for(Node leafNode : leafNodes){

            Node current = leafNode;
            String binaryCode = "";
            while(current != tree.root && current != null){

                if(current.parent != null && current == current.parent.left){
                    binaryCode = "0" + binaryCode;
                }else if(current.parent != null && current == current.parent.right){
                    binaryCode = "1" + binaryCode;
                }
                current = current.parent;
            }
            chAndEncoding.put(leafNode.ch,binaryCode);
        }
        System.out.println(chAndEncoding);
        // 3.遍历每个字符进行编码
        StringBuffer strEncoded = new StringBuffer();
        for(char ch : str.toCharArray()){
            strEncoded.append(chAndEncoding.get(ch));
        }
        return strEncoded.toString();
    }

测试:

    public static void main(String[] args) {
        Map<Character,Long> map = new HashMap<Character, Long>();
        map.put('a',5l);
        map.put('b',24l);
        map.put('c',7l);
        map.put('d',17l);
        map.put('e',34l);
        map.put('f',5l);
        map.put('g',13l);
        System.out.println(encode("abcd",map));
    }

结果:

{a=01001, b=10, c=0101, d=11, e=00, f=01000, g=011}
0100110010111

3）解码:给定二进制字符串，以及"单词-频次Map“，构建huffman树，将给定二进制字符串转成原未经编码的字符串。

首先使用"单词-频次"Map 构建huffman树。

然后按照给定的二进制字符串，挨个进行从根的查找，找到叶子节点后就转成原字符，从下一个字符串索引开始继续解码。

    /**
     * 解码过程
     * @param binStr
     * @param charsAndCounts
     * @return
     */
    public static String decode(
            String binStr,
            Map<Character,Long> charsAndCounts){
        // 1.获得Huffman树
        Tree tree = buildHuffmanTree(charsAndCounts);

        // 2.按照给定的二进制字符串，挨个进行从根的查找，找到叶子节点后就转成原字符，从下一个字符串索引开始继续解码。
        StringBuffer originalStr = new StringBuffer();
        int i = 0;

        while(i < binStr.length()){
            char ch = '\0';
            Node current = tree.root;
            while(current.ch ==null && i < binStr.length()){
                ch = binStr.charAt(i);
                if(ch == '1'){
                    current = current.right;
                }else if(ch == '0'){
                    current = current.left;
                }
                i++;
            }
            originalStr.append(current.ch);
        }
        return originalStr.toString();
    }

测试:

    public static void main(String[] args) {
        Map<Character,Long> map = new HashMap<Character, Long>();
        map.put('a',5l);
        map.put('b',24l);
        map.put('c',7l);
        map.put('d',17l);
        map.put('e',34l);
        map.put('f',5l);
        map.put('g',13l);
        System.out.println(encode("abcd",map));
        System.out.println(decode("0100110010111",map));
    }

结果:

{a=01001, b=10, c=0101, d=11, e=00, f=01000, g=011}
0100110010111
abcd
abcd