哈夫曼树与哈夫曼编码

目的

1. 直观的了解哈弗曼树与哈弗曼编码
2. 证明: 哈弗曼编码是最优的变⻓编码

前置知识

什么是编码

ASCLL编码:
‘a’ = 97 = $01100001_2$
‘0’ = 48 = $00110000_2$

注意:计算机中任何信息都是以二进制存储的

信息‘aa00’ = $01100001、01100001、00110000、00110000$在一台计算机传输至另一台计算机，传输 32 个比特位 假设计算机的网络是 32bit/s, 则用时 1s

特定场景：只有 a,b,0,1四种字符需要传输

自定义编码：

a:00 b:01 0: 10 1: 11

“aa00” = $00、00、10、10$

在带宽不变的情况下，当前只需要传输 0.25s

定长编码与变长编码

1. ASCLL 码与特定场景的自定义编码都属于定长编码
2. 对于每一个字符，编码长度都相同，这就是定长编码
3. UTF-8 是变长编码，UTF-16是定长编码
4. 对于每一个字符，编码长度不相同，这就是变长编码
5. 变长编码一定不差于定长编码

变长编码应用场景

特定场景：

1. 只有四种字符，a b 0 1
2. 字符出现的概率不同：

a : 0.8， b: 0.05， 0: 0.1， 1: 0.05

平均编码长度：

$l_i$: 每个字符的编码长度

$p_i$: 每个字符出现的概率

$$avg(l)=\sum (l_i\ast p_i)$$

假设平均编码长度为 1.16， 则传输 100 个字符需要传输 116 个比特位

自定义平均编码长度$$avg(l)=2\ast \sum (p_i)=2$$

新的自定义编码：

a: 1 ， b: 01， 0: 000， 1:001

平均编码长度：

$$avg(l)=1\ast 0.8+2\ast 0.05+3\ast 0.1+3\ast 0.05=1.35$$

100个字符，平均只需传输 135 个比特位。

哈弗曼编码

1. 首先，统计每一种字符出现的概率
2. 将 n 个字符，建立为一棵哈弗曼树
3. 每一个字符都落在叶子节点上
4. 按照左 0 右 1 的形式，将编码读取出来

举例：

新的哈弗曼编码：

a:0， b:110， 0: 10， 1:111

因为每一个字符都落在叶子节点上，所以不可能有某个字符是另一个字符的前缀。

平均编码长度：$$avg(l)=1\ast 0.8+3\ast 0.05+2\ast 0.1+3\ast 0.05=1.3$$

结论：哈弗曼编码是最优的变长编码。

证明：哈弗曼编码是最优的变长编码

证明：$E={\sum }_i(p_i\ast l_i)$最小。

假设哈弗曼树的树高为 H（树高从 0 开始），在第$l$层的某个节点，其所覆盖的叶子节点数量为$2^{(H-l)}$。

第$i$个字符的编码长度为$l_i$,在哈弗曼树对应的$l_i$层，所能覆盖的叶子节点数量为$2^{H-l_i}$,约束条件为：

$$2^{H-l_1}+2^{H-l_2+...+H-l_n}<=2^H$$

两边同时除以$2^H$,不等式变成：

$$\frac{1}{2^{l_1}}+\frac{1}{2^{l_2}}+...+\frac{1}{2^{l_n}}<=1$$

设$l_i^{\prime }=-l_i$,则上述不等式变成

$$2^{l_1^{\prime }}+2^{l_2^{\prime }}+...+2^{l_n^{\prime }}<=1$$

问题为求$l_i$,使得${\sum }_i(p_i\ast l_i)$最小，即求$l_i^{\prime }$,使得$-{\sum }_i(p_i\ast l_i^{\prime })$最小，约束条件为：

$$\sum _i(2^{l_i^{\prime }})<=1$$

设$I_i=2^{l_i^{\prime }}$,则$l_i^{\prime }=lo{g}_2(I_i)$.则问题同构为：

目标：$-{\sum }_i(p_i\ast lo{g}_2(I_i))$最小；

约束条件为：${\sum }_i(I_i)<=1$。

重写目标最小值函数：

$$-(p_{1}log(I_1)+p_{2}log(I_2)+...+I_{n}log(p_n))$$

约束条件：

$$I_1+I_2+...+I_n<=1$$

假设目标函数达到最小值时，$$I_1+I_2+...+I_n<1$$

设余量$$1-\sum (I_i)=I_x^{\prime }$$

不妨设$I_x^{\prime }$可以加到$I_i$上，但是$I_i$加一个余量时，目标函数$-(p_{1}log(I_1)+p_{2}log(I_2)+...+I_{n}log(p_n))$又会变小一点，所以余量$I_x^{\prime }$一定等于0。从而得出，当目标函数达到最小值时，一定有：

$$I_1+I_2+...+I_n=1$$

即
$$I_n=1-(I_1+...+I_{n-1})$$

令$$J=(I_1+...+I_{n-1})$$

则目标函数变为：

$$F=-(p_{1}log(I_1)+p_{2}log(I_2)+...+p_{n}log(1-J))$$

令 F 对$I_i$求偏导，F 达到最小值时偏导应都为 0，从而可以得到：

$$\frac{p_i}{I_i\ln 2}=\frac{p_n}{(1-J)\ln 2}$$

即$$\frac{p_1}{I_1}=\frac{p_2}{I_2}=...=\frac{p_{n-1}}{I_{n-1}}=\frac{p_n}{I_n}$$

又因为$$\sum _i(p_i)=1$$

$$\sum _i(I_i)=1$$

所以当目标函数达到最小值时一定有$$p_i=I_i$$

熵的定义为：$$-\sum (p_i\log (p_i))$$

正好是$p_i=I_i$的情况。交叉熵$-\sum (p_i\log (q_i))$就表示概率向量$p_i$和$q_i$的相似程度，越相似交叉熵越小。

某个字符的概率越大，对应的编码长度应该越小，这样的情况下平均编码长度最小，这就是哈弗曼编码。

证毕。

注意这种证明并不严谨，因为证明中$l_i$可以是小数，求导也是实数域，但是实际过程中只能是整数。

证明过程总结：

1. 首先表示平均编码长度，求解公式最优解
2. 最终，推到得出和熵与交叉熵之间的关系。

哈夫曼编码的代码演示

#include <stdio.h>
#include <stdlib.h>
#define swap(a, b) {\
        __typeof(a) temp = a;\
        a = b;\
        b = temp;\
}
typedef struct Node {
        char ch;
        double p;
        struct Node *lchild, *rchild;
}Node;
Node *getNewNode(char ch, double per) {
        Node *p = (Node *)malloc(sizeof(Node));
        p->ch = ch;
        p->p = per;
        p->lchild = p->rchild = NULL;
        return p;
}
Node *combineNode(Node *a, Node *b) {
        Node *p = getNewNode(0, a->p + b->p);
        p->lchild = a;
        p->rchild = b;
        return p;
}
void pick_min(Node **arr, int n) {
        for (int j = n - 1; j >= 0; j--) {
                if (arr[j]->p < arr[n]->p) {
                        swap(arr[j], arr[n]);
                }
        }
        return;
}
Node *getHaffmanTree(Node **arr, int n) {
        for (int i = 1; i < n; i++) {
                pick_min(arr, n - i);
                pick_min(arr, n - i - 1);
                arr[n - i - 1] = combineNode(arr[n - i], arr[n - i - 1]);
        }
        return arr[0];
}
void __output_encode(Node *root, char *str, int k) {
        str[k] = 0;
        if (root->lchild == NULL && root->rchild == NULL) {
                printf("%c %s\n", root->ch, str);
                return;
        }
        str[k] = '0';
        __output_encode(root->lchild, str, k+1);
        str[k] = '1';
        __output_encode(root->rchild, str, k+1);
        return;
}
void output_encode(Node *root) {
        char str[100];
        __output_encode(root, str, 0);
        return;
}
void clear(Node *p) {
        if (p == NULL) return;
        clear(p->lchild);
        clear(p->rchild);
        free(p);
        return;
}
int main() {
        int n;
        Node **arr;
        scanf("%d", &n);
        arr = (Node **)malloc(sizeof(Node *) * n);
        for (int i = 0; i < n; i++) {
                char ch[10];
                double p;
                scanf("%s%lf", ch, &p);
                arr[i] = getNewNode(ch[0], p);
        }
        Node *root = getHaffmanTree(arr, n);
        output_encode(root);
        clear(root);
        free(arr);
        return 0;
}

总结：使用c语言实现，按照哈夫曼编码的基本定义实现。