算法导论之哈夫曼编码
今天和大家一起讨论Haffman编码，哈夫曼编码是基于哈夫曼树，也可以被称为最有二叉树，哈夫曼编码可以有效的压缩数据，通常可以节省20%～90%，具体的压缩率依赖于数据的特性。首先给大家介绍一下什么是最优二叉树；在介绍什么是最有二叉树之前，先说明两个概念 ，
i>叶子节点的路径长度：从根到叶子节点的边的个数；
ii>叶子节点的带权路径长度（WPL）：叶子节点的权值 * 路径长度；
（1） 最优二叉树（Haffman Tree）：一颗二叉树的所有叶子节点的带权路径长度之和最小。
例：有节点 A(9)、B(2)、C(7)、D(4)
第一种构建二叉树的方式：
X
/ \
X X
/ \ / \
A B C D
其WPL值为：（9 + 2+ 7 + 4）* 2 = 44
第二种构建二叉树的方式：
X
/ \
A X
/ \
C X
/ \
B D
将权值大放在靠近根结点的位置；其WPL值为：9 + 7 * 2 + （2 + 4）*3 = 41
（2）构造哈夫曼树 ------->贪心算法
i> 初始 ：森林：F = {A（9）、B（2）、C（7）、D（4）}
ii>处理：从森林中选取权值最小和次小的2颗树构建成一颗新二叉树，并放回森林，并删除原来的2颗二叉树
iii>重复ii>，直至森林中只剩一颗二叉树。
例：F = {A、B、C、D}
i> 6
/ \
B D ---> 放回森林，并删除B、D两颗二叉树
(2) (4)
ii> 13
/ \
6 C(7) --->放回森林，并删除6、C两颗二叉树
/ \
B D
(2) (4)
iii> 22
/ \
A 13
(9) / \
6 C(7)
/ \
B D
(2) (4)
在构造二叉树时会遇到以下的几个问题：
A>如何查找权值最小和次小的两颗子树：-------贪心准则
B>如何构建一颗新的子树：
i>创建双亲 ----权值为左右子树之和
ii>左子女 --->最小 右子女 --->次小
C>如何知道森林中只剩下一颗子树 -------->结束条件
i>Haffman树无单分支节点
ii>经过n - 1次就可构建完成
实现Haffman Tree
1)存储结构：
word weight left right parent code
A 9 -1 -1 -1
B 2 -1 -1 -1
C 7 -1 -1 -1
D 4 -1 -1 -1
定义存储结构：
下面实现接口：
#include <stdio.h>
#include <stdlib.h>
#include "hafman.h"
#include "tools.h"
HaffTree *init(char * s,int * a,int n)
{
HaffTree *F = {0};
int i = 0;
F = (HaffTree *)Malloc(((2 * n) - 1) * sizeof(HaffTree));
for(i = 0;i < n;i++){
F[i].word = s[i];
F[i].weight = a[i];
F[i].left = -1;
F[i].right = -1;
F[i].parent = -1;
}
return F;
}
void Creat_HaffmanTree(HaffTree *F,int n)
{
int i = 0;
int k1 = 0;
int k2 = 0;
int j = 0;
for(i = 0;i < n -1 ; ++i){
for(k1 = 0;k1 < n + i && F[k1].parent != -1;k1++);
for(k2 = k1 + 1;k2 < n + i && F[k2].parent != -1;k2++);
for(j = k2;j < n + i;j++){
if(F[j].parent == -1){
if(F[j].weight < F[k1].weight){
k2 = k1;
k1 = j;
}else if(F[j].weight < F[k2].weight){
k2 = j;
}
}
}
F[n + i].word = 'x';
F[n + i].weight = F[k1].weight + F[k2].weight;
F[n + i].left = k1;
F[n + i].right = k2;
F[n + i].parent = -1;
F[k1].parent = n + i;
F[k2].parent = n + i;
}
}
void Haffman_Code(HaffTree *F,int n)
{
int i = 0;
int c = 0;
int p = 0;
int k = 0;
for(i = 0;i < n;++i){
F[i].code = (int *)Malloc((n + 1) * sizeof(int));
F[i].code[0] = 0;
c = i;
while(F[c].parent != -1){
p = F[c].parent;
k = ++F[i].code[0];
if(F[p].left == c){
F[i].code[k] = 0;
}else{
F[i].code[k] = 1;
}
c = p;
}
}
}
void Print_Haffmancode(HaffTree *F,int n)
{
int i = 0;
int j = 0;
for(i = 0;i < n;++i){
printf("%c:",F[i].word);
for(j = F[i].code[0];j > 0;--j){
printf("%2d",F[i].code[j]);
}
printf("\n");
}
}
void ClearHaffman(HaffTree *F,int n)
{
int i = 0;
for(i = 0;i < n;++i){
free(F[i].code);
}
free(F);
}
测试代码：
测试结果：
从程序执行结果上可看出实现了压缩数据，节省了空间。