算法导论之哈夫曼编码

     今天和大家一起讨论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);
}

测试代码：

测试结果：

从程序执行结果上可看出实现了压缩数据，节省了空间。