哈夫曼树(Huffman)

哈夫曼树

Huffman 编码问题

问题引入

什么是编码？

简单说就是建立【字符】到【数字】的对应关系，如下面大家熟知的 ASC II 编码表，例如，可以查表得知字符【a】对应的数字是十六进制数【0x61】

\	00	01	02	03	04	05	06	07	08	09	0a	0b	0c	0d	0e	0f
0000	00	01	02	03	04	05	06	07	08	09	0a	0b	0c	0d	0e	0f
0010	10	11	12	13	14	15	16	17	18	19	1a	1b	1c	1d	1e	1f
0020	20	!	"	#	$	%	&	’	(	)	*	+	,	-	.	/
0030	0	1	2	3	4	5	6	7	8	9	:	;	<	=	>	?
0040	@	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
0050	P	Q	R	S	T	U	V	W	X	Y	Z	[	\	]	^	_
0060	`	a	b	c	d	e	f	g	h	i	j	k	l	m	n	o
0070	p	q	r	s	t	u	v	w	x	y	z	{	|	}	~	7f

注：一些直接以十六进制数字标识的是那些不可打印字符

传输时的编码

• java 中每个 char 对应的数字会占用固定长度 2 个字节
• 如果在传输中仍采用上述规则，传递 abbccccccc 这 10 个字符
  • 实际的字节为 0061006200620063006300630063006300630063（16进制表示）
  • 总共 20 个字节，不经济

现在希望找到一种最节省字节的传输方式，怎么办？

假设传输的字符中只包含 a，b，c 这 3 个字符，有同学重新设计一张二进制编码表，见下图

• 0 表示 a
• 1 表示 b
• 10 表示 c

现在还是传递 abbccccccc 这 10 个字符

• 实际的字节为 01110101010101010 （二进制表示）
• 总共需要 17 bits，也就是 2 个字节多一点，行不行？

不行，因为解码会出现问题，因为 10 会被错误的解码成 ba，而不是 c

• 解码后结果为 abbbababababababa，是错误的

怎么解决？必须保证编码后的二进制数字，要能区分它们的前缀（prefix-free）

用满二叉树结构编码，可以确保前缀不重复

• 向左走 0，向右走 1
• 走到叶子字符，累计起来的 0 和 1 就是该字符的二进制编码

再来试一遍

• a 的编码 0
• b 的编码 10
• c 的编码 11

现在还是传递 abbccccccc 这 10 个字符

• 实际的字节为 0101011111111111111（二进制表示）
• 总共需要 19 bits，也是 2 个字节多一点，并且解码没有问题了，行不行？

这回解码没问题了，但并非最少字节，因为 c 的出现频率高（7 次）a 的出现频率低（1 次），因此出现频率高的字符编码成短数字更经济

考察下面的树

• 00 表示 a
• 01 表示 b
• 1 表示 c

现在还是传递 abbccccccc 这 10 个字符

• 实际的字节为 000101 1111111 （二进制表示）
• 总共需要 13 bits，这棵树就称之为 Huffman 树
• 根据 Huffman 树对字符和数字进行编解码，就是 Huffman 编解码

Huffman 树

public class HuffmanTree {

    Node root;
    String code;
    private static class Node{
        char ch;
        int freq;
        String code;
        Node left;
        Node right;

        public Node(char ch) {
            this.ch = ch;
        }

        public Node(char ch, int freq) {
            this.ch = ch;
            this.freq = freq;
        }

        public Node(int freq, Node left, Node right) {
            this.freq = freq;
            this.left = left;
            this.right = right;
        }

        public boolean isLeaf(){
            return this.left == null && this.right == null;
        }
    }

    public HuffmanTree(String s){
        char[] charArray = s.toCharArray();
        Map<String,Integer> map = new HashMap();
        for (char c : charArray) {
            Integer i = map.getOrDefault(String.valueOf(c),0);
            map.put(String.valueOf(c),i+1);
        }
        PriorityQueue<Node> queue = new PriorityQueue<>(Comparator.comparingInt(v -> v.freq));
        for (String string : map.keySet()) {
            Node node = new Node(string.charAt(0), map.get(string));
            queue.add(node);
        }
        while(queue.size() > 1){
            Node n1 = queue.poll();
            Node n2 = queue.poll();
            Node node = new Node(n1.freq + n2.freq, n1, n2);
            queue.add(node);
        }
        root = queue.peek();
        s = doEncode(root,new StringBuilder(),s);
        code = s;
    }
}

Huffman 编解码

补充两个方法，注意为了简单期间用了编解码都用字符串演示，实际应该按 bits 编解码

public class HuffmanTree {
    // ...

    // 编码
    private String doEncode(Node node,StringBuilder sb,String s){
        if(!node.isLeaf()){
            s = doEncode(node.left,sb.append(0),s);
            sb.deleteCharAt(sb.length()-1);
            s = doEncode(node.right,sb.append(1),s);
            sb.deleteCharAt(sb.length()-1);
        }else{
            node.code = sb.toString();
            while(s.contains(String.valueOf(node.ch))){
                s = s.replace(String.valueOf(node.ch), node.code);
            }
        }
        return s;
    }

    public String encode(){
        return code;
    }

    public String decode(String code){
        Node node = root;
        StringBuilder sb = new StringBuilder();
        char[] charArray = code.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            if(charArray[i] == '0'){
                node = node.left;
            }else {
                node = node.right;
            }
            if(node.isLeaf()){
                sb.append(node.ch);
                node = root;
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        HuffmanTree tree = new HuffmanTree("aabcccccc");
        String encode = tree.encode();
        System.out.println(encode);
        String decode = tree.decode(encode);
        System.out.println(decode);
    }
}