霍夫曼编码（Huffman Coding）

霍夫曼编码(Huffman Coding)是一种编码方法，霍夫曼编码是可变字长编码(VLC)的一种。

霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

霍夫曼编码的具体步骤如下：

1）将信源符号的概率按减小的顺序排队。

2）把两个最小的概率相加，并继续这一步骤，始终将较高的概率分支放在右边，直到最后变成概率１。

3）画出由概率１处到每个信源符号的路径，顺序记下沿路径的０和１，所得就是该符号的霍夫曼码字。   

4）将每对组合的左边一个指定为0，右边一个指定为1（或相反）。

例：现有一个由5个不同符号组成的30个符号的字符串：

BABACAC ADADABB CBABEBE DDABEEEBB

1首先计算出每个字符出现的次数（概率）：

2把出现次数（概率）最小的两个相加，并作为左右子树，重复此过程，直到概率值为1

第一次：将概率最低值3和4相加，组合成7：

第二次：将最低值5和7相加，组合成12：

第三次：将8和10相加，组合成18：

第四次：将最低值12和18相加，结束组合：

3 将每个二叉树的左边指定为0，右边指定为1

4 沿二叉树顶部到每个字符路径，获得每个符号的编码

我们可以看到出现次数（概率）越多的会越在上层，编码也越短，出现频率越少的就越在下层，编码也越长。当我们编码的时候，我们是按“bit”来编码的，解码也是通过bit来完成，如果我们有这样的bitset “″ 那么其解码后就是 “ABBDE”。所以，我们需要通过这个二叉树建立我们Huffman编码和解码的字典表。

这里需要注意的是，Huffman编码使得每一个字符的编码都与另一个字符编码的前一部分不同，不会出现像’A’：00，  ’B’：001，这样的情况，解码也不会出现冲突。

霍夫曼编码的局限性

利用霍夫曼编码，每个符号的编码长度只能为整数，所以如果源符号集的概率分布不是2负n次方的形式，则无法达到熵极限；输入符号数受限于可实现的码表尺寸；译码复杂；需要实现知道输入符号集的概率分布；没有错误保护功能。

霍夫曼编码实现 （C++实现）：

int main() { int n, w; char c; string s; cout << "input size of char : "; cin >> n; BinartNodes bn; for(int i = 0; i != n; ++i) { cout << "input char and weight: "; cin >> c >> w; bn.add_Node((Node(c, w))); cin.clear(); } while(bn.size() != 1) { Node n1 = bn.pop(), //获取前两个权重最小的结点 n2 = bn.pop(); Node h(' ', n1.get_weight() + n2.get_weight()); //新建结点，权重为前两个结点权重和 if( n1.get_weight() < n2.get_weight()) //权重较小的结点在新结点左边 { h.set(n1, n2); //设置新结点左右子结点 } else { h.set(n2, n1); } bn.add_Node(h); //将新结点插入到multiset中 } encodeing(bn.get_Node(), s); //编码 cout << "input huffman code: "; cin >> s; cout << "decoded chars: "; decoding(bn.get_Node(), s); //解码 }

Handle.h句柄类：

/*Handle.h*/ //句柄模型类 template 
   
     class Handle{ public: Handle(Type *ptr = 0): pn(ptr), use(new size_t(1)) {} Type& operator*(); //重载操作符* Type* operator->(); //重载操作符-> const Type& operator*() const; const Type* operator->() const; Handle(const Handle &h): pn(h.pn), use(h.use) { ++*use; } //复制操作 Handle& operator=(const Handle &h); //重载操作符=，赋值操作 ~Handle() {rem_ref(); } //析构函数 private: Type *pn; //对象指针 size_t *use; //使用次数 void rem_ref() { if (--*use == 0) {delete pn; delete use; } } }; template 
    
      inline Type& Handle 
     
       ::operator*() { if (pn) return *pn; throw runtime_error("dereference of unbound Handle"); } template 
      
        inline const Type& Handle 
       
         ::operator*() const { if (pn) return *pn; throw runtime_error("dereference of unbound Handle"); } template 
        
          inline Type* Handle 
         
           ::operator->() { if (pn) return pn; throw runtime_error("access through unbound handle"); } template 
          
            inline const Type* Handle 
           
             ::operator->() const { if (pn) return pn; throw runtime_error("access through unbound handle"); } template 
            
              inline Handle 
             
               & Handle 
              
                ::operator=(const Handle &rhs) { ++*rhs.use; rem_ref(); pn = rhs.pn; use = rhs.use; return *this; } 
               
              
             
            
           
          
         
        
       
      
     
   

/*Node.h*/ template             class Handle; class Node{ friend class Handle               ; //句柄模型类 public: Node():ch(' '),wei(0), bits(), lc(), rc(){} Node(const char c, const int w): ch(c), wei(w), bits(), lc(), rc(){} Node(const Node &n){ch = n.ch; wei = n.wei; bits = n.bits; lc = n.lc; rc = n.rc; } virtual Node* clone()const {return new Node( *this);} int get_weight() const {return wei;} //获取权重 char get_char() const {return ch; } //获得字符 Node &get_lchild() {return *lc; } //获得左结点 Node &get_rchild() {return *rc; } //获得右结点 void set(const Node &l, const Node &r){ //设置左右结点 lc = Handle                 (new Node(l)); rc = Handle                   (new Node(r));} void set_bits(const string &s){bits = s; } //设置编码 private: char ch; //字符 int wei; //权重 string bits; //编码 Handle                     lc; //左结点句柄 Handle                       rc; //右结点句柄 }; inline bool compare(const Node &lhs, const Node &rhs); //multiset比较函数 inline bool compare(const Node &lhs, const Node &rhs) { return lhs.get_weight() < rhs.get_weight(); } class BinartNodes{ typedef bool (*Comp)(const Node&, const Node&); public: BinartNodes():ms(compare) {} //初始化ms的比较函数 void add_Node(Node &n){ms.insert(n); } //增加Node结点 Node pop(); //出结点 size_t size(){return ms.size(); } //获取multiset大小 Node get_Node() {return *ms.begin();} //获取multiset第一个数据 private: multiset                         ms; }; /*Node.cpp*/ #include "Node.h" Node BinartNodes::pop() { Node n = *ms.begin(); //获取multiset第一个数据 ms.erase(ms.find(*ms.begin())); //从multiset中删除该数据 return n; }                                                               

霍夫曼编码实现 （C语言实现）：

#include 
   
     #include 
    
      #include 
     
       #include 
      
        #define MAXBIT 100 #define MAXVALUE 10000 #define MAXLEAF 30 #define MAXNODE MAXLEAF*2 -1 typedef struct { int bit[MAXBIT]; int start; } HCodeType; /* 编码结构体 */ typedef struct { int weight; int parent; int lchild; int rchild; char value; } HNodeType; /* 结点结构体 */ /* 构造一颗哈夫曼树 */ void HuffmanTree (HNodeType HuffNode[MAXNODE], int n) { /* i、j： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值， x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/ int i, j, m1, m2, x1, x2; /* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */ for (i=0; i<2*n-1; i++) { HuffNode[i].weight = 0;//权值 HuffNode[i].parent =-1; HuffNode[i].lchild =-1; HuffNode[i].rchild =-1; HuffNode[i].value=' '; //实际值，可根据情况替换为字母 } /* end for */ /* 输入 n 个叶子结点的权值 */ for (i=0; i