简介

哈夫曼编码，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码。主要思想就是：依据编码内容出现的频率来控制编码的具体字符的长度，以此来达到控制存储空间的目的。

原理

1. 哈夫曼树的构造原理上来讲就是，让二叉树具有最优带权路径，那么也就是权重越大的节点越靠近根节点，够早的过程就是一个依据权重来构建二叉树的过程

2. 假设有4个结点 \(a, b, c, d\),权值分别为 \(7, 5, 2, 4\),构造以此4个结点为叶子结点的二叉树。
   
   
   以上的都是最优二叉树，也就是哈夫曼树，构造一般来说的话，采取第二种，遵循左小右大的规则，契合于二叉搜索树的概念。

3. 带权路径长度
   我们规定一个概念：代全路径长度：

   • Now assign to each leaf of the tree a value, \(f(c)\), which is the frequency of occurrence of the character c represented by the leaf.
   • Let \(d_T(c)\) be the depth of character c’s leaf in the tree T.
   • 所以我们带权路径长度的计算公式就是\(B(T) =\displaystyle\sum^{N}_{n=1,c \in C}{f(c)\times d_T(c)}\)

4. 关于哈夫曼输的注意点

   1. 满二叉树不一定是哈夫曼树
   2. 哈夫曼树中权越大的叶子离根越近（很好理解，WPL最小的二叉树）
   3. 具有相同带权结点的哈夫曼树不唯一
   4. 哈夫曼树的结点的度数为0或2，没有度为1的结点。
   5. 包含n个叶子结点的哈夫曼树中共有2n – 1个结点。
   6. 包含n棵树的森林要经过n–1次合并才能形成哈夫曼树，共产生n–1个新结点

哈夫曼建树和编码过程

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//haffman 树的结构
typedef struct
{
    //叶子结点权值
    unsigned int weight;
    //指向双亲，和孩子结点的指针
    unsigned int parent;
    unsigned int lChild;
    unsigned int rChild;
} Node, *HuffmanTree;

//动态分配数组，存储哈夫曼编码
typedef char *HuffmanCode;

//选择两个parent为0，且weight最小的结点s1和s2的方法实现
//n 为叶子结点的总数，s1和 s2两个指针参数指向要选取出来的两个权值最小的结点
void select(HuffmanTree *huffmanTree, int n, int *s1, int *s2)
{
    //标记 i
    int i = 0;
    //记录最小权值
    int min;
    //遍历全部结点，找出单节点
    for(i = 1; i <= n; i++)
    {
        //如果此结点的父亲没有，那么把结点号赋值给 min，跳出循环
        if((*huffmanTree)[i].parent == 0)
        {
            min = i;
            break;
        }
    }
    //继续遍历全部结点，找出权值最小的单节点
    for(i = 1; i <= n; i++)
    {
        //如果此结点的父亲为空，则进入 if
        if((*huffmanTree)[i].parent == 0)
        {
            //如果此结点的权值比 min 结点的权值小，那么更新 min 结点，否则就是最开始的 min
            if((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
            {
               min = i;
            }
        }
    }
    //找到了最小权值的结点，s1指向
    *s1 = min;
    //遍历全部结点
    for(i = 1; i <= n; i++)
    {
        //找出下一个单节点，且没有被 s1指向，那么i 赋值给 min，跳出循环
        if((*huffmanTree)[i].parent == 0 && i != (*s1))
        {
            min = i;
            break;
        }
    }
    //继续遍历全部结点，找到权值最小的那一个
    for(i = 1; i <= n; i++)
    {
        if((*huffmanTree)[i].parent == 0 && i != (*s1))
        {
            //如果此结点的权值比 min 结点的权值小，那么更新 min 结点，否则就是最开始的 min
            if((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
            {
               min = i;
            }
        }
    }
    //s2指针指向第二个权值最小的叶子结点
    *s2 = min;
}

//创建哈夫曼树并求哈夫曼编码的算法如下，w数组存放已知的n个权值
void createHuffmanTree(HuffmanTree *huffmanTree, int w[], int n)
{
    //m 为哈夫曼树总共的结点数，n 为叶子结点数
    int m = 2 * n - 1;
    //s1 和 s2 为两个当前结点里，要选取的最小权值的结点
    int s1;
    int s2;
    //标记
    int i;
    // 创建哈夫曼树的结点所需的空间，m+1，代表其中包含一个头结点
    *huffmanTree = (HuffmanTree)malloc((m + 1) * sizeof(Node));
    //1--n号存放叶子结点，初始化叶子结点，结构数组来初始化每个叶子结点，初始的时候看做一个个单个结点的二叉树
    for(i = 1; i <= n; i++)
    {

        //其中叶子结点的权值是 w【n】数组来保存
        (*huffmanTree)[i].weight = w[i];
        //初始化叶子结点（单个结点二叉树）的孩子和双亲，单个结点，也就是没有孩子和双亲，==0
        (*huffmanTree)[i].lChild = 0;
        (*huffmanTree)[i].parent = 0;
        (*huffmanTree)[i].rChild = 0;
    }// end of for
    //非叶子结点的初始化
    for(i = n + 1; i <= m; i++)
    {
        (*huffmanTree)[i].weight = 0;
        (*huffmanTree)[i].lChild = 0;
        (*huffmanTree)[i].parent = 0;
        (*huffmanTree)[i].rChild = 0;
    }

    printf("\n HuffmanTree: \n");
    //创建非叶子结点，建哈夫曼树
    for(i = n + 1; i <= m; i++)
    {
        //在(*huffmanTree)[1]~(*huffmanTree)[i-1]的范围内选择两个parent为0
        //且weight最小的结点，其序号分别赋值给s1、s2
        select(huffmanTree, i-1, &s1, &s2);
        //选出的两个权值最小的叶子结点，组成一个新的二叉树，根为 i 结点
        (*huffmanTree)[s1].parent = i;
        (*huffmanTree)[s2].parent = i;
        (*huffmanTree)[i].lChild = s1;
        (*huffmanTree)[i].rChild = s2;
        //新的结点 i 的权值
        (*huffmanTree)[i].weight = (*huffmanTree)[s1].weight + (*huffmanTree)[s2].weight;

        printf("%d (%d, %d)\n", (*huffmanTree)[i].weight, (*huffmanTree)[s1].weight, (*huffmanTree)[s2].weight);
    }

    printf("\n");
}

//哈夫曼树建立完毕，从 n 个叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码
void creatHuffmanCode(HuffmanTree *huffmanTree, HuffmanCode *huffmanCode, int n)
{
    //指示biaoji
    int i;
    //编码的起始指针
    int start;
    //指向当前结点的父节点
    int p;
    //遍历 n 个叶子结点的指示标记 c
    unsigned int c;
    //分配n个编码的头指针
    huffmanCode=(HuffmanCode *)malloc((n+1) * sizeof(char *));
    //分配求当前编码的工作空间
    char *cd = (char *)malloc(n * sizeof(char));
    //从右向左逐位存放编码，首先存放编码结束符
    cd[n-1] = \'\0\';
    //求n个叶子结点对应的哈夫曼编码
    for(i = 1; i <= n; i++)
    {
        //初始化编码起始指针
        start = n - 1;
        //从叶子到根结点求编码
        for(c = i, p = (*huffmanTree)[i].parent; p != 0; c = p, p = (*huffmanTree)[p].parent)
        {
            if( (*huffmanTree)[p].lChild == c)
            {
                //从右到左的顺序编码入数组内
                 cd[--start] = \'0\';  //左分支标0
            }
            else
            {
                cd[--start] = \'1\';  //右分支标1
            }
        }// end of for
        //为第i个编码分配空间
        huffmanCode[i] = (char *)malloc((n - start) * sizeof(char));

        strcpy(huffmanCode[i], &cd[start]);
    }

    free(cd);
    //打印编码序列
    for(i = 1; i <= n; i++)
    {
         printf("HuffmanCode of %3d is %s\n", (*huffmanTree)[i].weight, huffmanCode[i]);
    }

    printf("\n");
}

int main(void)
{
    HuffmanTree HT;
    HuffmanCode HC;
    int *w,i,n,wei;

    printf("\nn = " );

    scanf("%d",&n);

    w=(int *)malloc((n+1)*sizeof(int));

    printf("\ninput the %d element\'s weight:\n",n);

    for(i=1; i<=n; i++)
    {
        printf("%d: ",i);
        fflush(stdin);
        scanf("%d",&wei);
        w[i]=wei;
    }

    createHuffmanTree(&HT, w, n);
    creatHuffmanCode(&HT,&HC,n);

    return 0;
}