这篇博客里我先是介绍了什么是哈夫曼树，然后给出了如何去构造其的算法，接着引进哈夫曼编码，最后拓展到了动态哈夫曼树。废话不多说，开始吧！
1. 什么是哈夫曼
要介绍哈夫曼树，得先了解几个概念：
- 扩充二叉树：在原来的二叉树(内结点)中出现空子树时，加上特殊的结点(外结点)，使得原结点在新树上不存在叶结点，假设有n个内结点和S个外结点，E表示从根结点到每个外结点的长度之和，I表示从根结点到每个内结点长度之和，长度即是经过的边的数量，性质如下：
- 性质1：S = n + 1
- 性质2：E = I + 2*n
-
加权路长：在扩充二叉树的基础上，若每个外结点都对应一个值，则假设lj是从根结点到某个外结点的路长，而wj是该外结点对应的值，则∑wj*lj便是加权路长。
-
哈夫曼树：对于给定的实数w1,w2,...,wm，构造一棵扩充二叉树，使其的加权路长最小，这棵树就是哈夫曼树。
2. 哈夫曼树的构造算法：
- 由给定的n个权值{w0,w1,...,wn-1}，构造具有n棵扩充二叉树的森林F={T0,T1,...,Tn-1}，其中每棵扩充二叉树Ti只有一个带权值wi的根结点，其左右子树均为空
- 在F中选取两棵根结点的权值最小的扩充二叉树，作为左右子树构造一棵新的二叉树，且置新的二叉树的根结点的权值是它们的和
- 在F中删除这两棵树，加入新树
- 重复2,3步，直到只剩一棵树
3. 哈夫曼编码
讲道理，假设给你一篇文档，里面全是a,b,c,d,e，你统计出来它们的出现频率，如下：
| 字符 | 概论 |
|---|---|
| a | 0.12 |
| b | 0.4 |
| c | 0.15 |
| d | 0.08 |
| e | 0.25 |
字母是以ASCII码存储的，一个字符8位，在知道概率的情况下，这种存储方式很浪费硬盘空间，设计一个编码方式，让它们在最小空间内存储，且具有前缀性(任何一个字符的编码不会是别的字符的编码前缀)，这时候哈夫曼编码应运而生。
只需要将字符概率看成权值即可，然后构造哈夫曼树，在左子树的边上标记'0'，右标记'1'，则每个字符的路径上标记相连即编码。
简单代码实现：
//假设C是一个n个字符的集合，其中每个字符c属于C且c.freq给出它们的概率，Q是以freq比较的最小优先队列
HUFFMAN(C)
{
n = |C|;
Q = C;
for i = 1 to n-1
allocate a new node z
z.left = x = EXTRACT_MIN(Q);
z.right = y = EXTRACT_MIN(Q);
z.freq = x.freq + y.freq;
INSERT(Q,z);
}
4. 动态哈夫曼
静态哈夫曼编码最大的缺点是它需要对原始数据进行两遍扫描：第一遍统计字符频率，第二遍根据频率得到的哈夫曼树对原始数据进行编码。而动态哈夫曼树对t+1个字符的编码是根据前面t个字符而来，不需要重新进行扫描。
-
一些定义
- 原始数据：需要被压缩的数据
- 压缩数据：被压缩过的数据
- n：字母表的长度
- aj：字母表的第j个字符
- t：已经处理的原始数据中字符的总个数
- k：已经处理数据中各不相同字符的个数
-
构造规则：
- 初始化，一个根节点和左分支，权值均为空
- 对每个结点都分配了一个序列号，序列号越大，该结点权值越大
- 每读进一个字符，若字符未出现，则在空叶结点右分支加入权值为1新结点，左分支加入权值为0的叶子结点，调整后，更新各结点权值；若已经出现过，调整后更新权值
- 调整方法：先以对应的叶结点为当前结点，重复地与具有相同权值的序号最大的结点进行交换，并且使后者的父亲结点作为新的当前结点，直到遇到根结点为止
例如，已经压缩完32个字符
接着压缩一个'b'，先要调整：
接着更新结点：
- 不多说，直接放代码：
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;
#define MAX_ORDER 512
struct Node
{
char data;
int weight;
int order;
Node* lchild;
Node* rchild;
Node* parent;
};
Node * root = new Node; // 定义哈夫曼树的根节点
vector<Node *> Weight; //存储同权重中最大序号的节点
vector<Node *> Leaf; //存储所有叶子节点
//初始化root和weight
void init()
{
root->order = 512;
root->weight = 0;
root->data = '0';
root->lchild = NULL;
root->rchild = NULL;
root->parent = NULL;
}
//参数化初始化nyt节点
void init_nyt(Node * nyt)
{
nyt->weight = 0;
nyt->order = 0;
nyt->data = '0';
nyt->lchild = NULL;
nyt->rchild = NULL;
nyt->parent = NULL;
}
//根到叶节点路径上所有节点权重加一
void increase(Node * leaf)
{
Node * tmp = leaf;
while(tmp != root)
{
tmp->weight += 1;
tmp = tmp->parent;
}
root->weight += 1;
}
//更新Weight
void change_weight(Node * present)
{
Node * tmp = present;
bool flag;
if(!Weight.size())
Weight.push_back(present);
else
{
while(tmp != root)
{
flag = false;
for(int num=static_cast<int>(Weight.size()),i=0;i < num;i++)
{
if(Weight[i]->order == tmp->order)
flag = true;
}
if(!flag)
Weight.push_back(tmp);
tmp = tmp->parent;
}
}
}
//返回同权重最大节点
Node * Max(int wei)
{
Node * Max;
int i = 0;
int num= static_cast<int>(Weight.size());
for(;i < num;i++)
{
if(Weight[i]->weight == wei)
{
Max = Weight[i];
break;
}
}
for(;i < num;i++)
{
if(Weight[i]->weight == wei && Weight[i]->order > Max->order)
Max = Weight[i];
}
return Max;
}
//交换节点以便维持哈夫曼树性质
void exchange(Node * present)
{
Node * tmp = present;
Node * max;
Node * p = NULL;
Node * p1, *p2;
int t;
if(present == root || present->weight == 0)
return;
else
{
while(tmp && tmp != root)
{
max = Max(tmp->weight);
if(max != tmp->parent && max->order > tmp->order)
{
p1 = max->parent;
p2 = tmp->parent;
p = p1;
t = tmp->order;
tmp->order = max->order;
max->order = t;
tmp->parent = p1;
max->parent = p2;
if(p1->lchild == max)
p1->lchild = tmp;
else
p1->rchild = tmp;
if(p2->lchild == tmp)
p2->lchild = max;
else
p2->rchild = max;
}
else
p = tmp->parent;
tmp = p;
}
}
}
//编码
void encode(ofstream & out)
{
Node * tmp;
Node * par;
vector<int> code;
int num1 = static_cast<int>(Leaf.size());
int num2;
for(int i=0;i<num1;i++)
{
code.clear();
out << Leaf[i]->data << ": ";
tmp = Leaf[i];
while(tmp != root)
{
par = tmp->parent;
if(par->lchild == tmp)
code.push_back(0);
else
code.push_back(1);
tmp = par;
}
num2 = static_cast<int>(code.size());
for(int j=0;j<num2;j++)
out << code[num2-1-j] << " ";
out << endl;
}
}
//添加信息，构建动态哈夫曼树
void Add(ifstream & in,ofstream & out)
{
string str;
in >> str;
Node * p;
Node * q; //记录当前的NYT节点
Node * nyt; //即NYT节点
Node * present; //记录当前节点
int i = 0;
bool flag;
while(str[i] != ' ')
{
flag = false;
int j = 0;
for(int num=static_cast<int>(Leaf.size());j < num;j++)
{
if(Leaf[j]->data == str[i])
{
flag = true;
break;
}
}
if(!flag)
{
if(!root->weight)
q = root;
p = new Node;
nyt = new Node;
init_nyt(nyt);
p->parent = nyt->parent = q;
p->weight = 0;
p->data = str[i];
p->order = q->order -1;
nyt->order = q->order -2;
q->lchild = nyt;
q->rchild = p;
present = p;
Leaf.push_back(p);
q = nyt;
}
else
present = Leaf[j];
exchange(present);
increase(present);
change_weight(present);
encode(out);
out << endl;
i ++;
}
}
int main()
{
ifstream in("data.in");
ofstream out("data.out");
init();
Add(in,out);
in.close();
out.close();
return 0;
}