哈夫曼树

介绍

哈夫曼树，英文名 Huffman Tree, 又称赫夫曼树或最优二叉树。其主要用途是在于解决哈夫曼编码。哈夫曼编码则目的是在字节长度一定下，尽可能传输较多的信息。这也就是要让出现在明文中次数较多的字符对应较短的编码。这样即可达到在字节长度一定下，传输较多内容。

为了介绍哈夫曼树的特点，先介绍一些名词，路径长度和带权路径长度。

• 路径长度是指一个结点到另外一个结点之间分支的数目。
• 带权路径长度是指每个分支上有权值，一个结点到另外一个结点所有路径权值总和。

树的路径长度则为从根结点出发到每一个叶结点的路径长度总和。树的带权路径长度则是从根结点出发到每一个叶节点的带权路径长度总和，叫做WPL。

哈夫曼树拥有最小的树的带权路径长度，其每个叶节点包含字符信息。如下图，第三棵则为哈夫曼树。

如何建立哈夫曼树

建立哈夫曼树的算法思想：
1.初始化： 根据给定的n个权值{w1,w2,…wn}构成n棵二叉树的集合F={T1,T2,..,Tn},其中每棵二叉树Ti中只有一个带权wi的根结点,左右子树均空.
2. 找最小树：在F中选择两棵根结点权值最小的树作为左右子树构造一棵新的二叉树,且至新的二叉树的根结点的权值为其左右子树上根结点的权值之和.
3. 删除与加入：在F中删除这两棵树,并将新的二叉树加入F中.
4. 判断：重复前两步（2和3）,直到F中只含有一棵树为止.该树即为哈夫曼树

举例如下图所示

哈夫曼编码

哈夫曼编码就是在哈夫曼树基础上，从根出发每个左分支标记为0，右分支标记为1，则叶子结点的编码内容就是从根到对应叶子结点走过的分支所形成的01串即为对应的编码内容。

实现代码

#include
#include
#include

#define BEGIN -1

/**
 * 哈夫曼树结点
 */
typedef struct {
    int weight;
    int parent, left, right;
}HTNode, *HuffmanTree;

typedef char ** HuffmanTable; //动态分配存储各个字符哈夫曼编码的表


/**
 * 从树集中选取parent = 0，weight最小的两个结点，其下标存入s1,12
 */
void select_min_two(HuffmanTree htree, int end, int *s1, int *s2)
{
    int min1, min2;
    int i = 1;
    while(htree[i].parent != 0 && i<=end)
        i++;
    min1 = htree[i].weight;
    *s1 = i;

    i++;
    while(htree[i].parent != 0 && i<=end)
        i++;
    if(htree[i].weight < min1){
        min2 = min1;
        *s2 = *s1;
        min1 = htree[i].weight;
        *s1 = i;
    }else{
        min2 = htree[i].weight;
        *s2 = i;
    }



    for(int j=i+1; j <= end; j++)
    {
        if(htree[j].parent != 0)
            continue;

        if(htree[j].weight < min1){
            min2 = min1;
            min1 = htree[j].weight;
            *s2 = *s1;
            *s1 = j;
        }else if(htree[j].weight >= min1 && htree[j].weight < min2){
            min2 = htree[j].weight;
            *s2 = j;
        }
    }
}

/**
 * htree: 建立之后的哈夫曼树
 * htable: 建立之后的哈夫曼编码表
 * w: n个字符的权值数组
 * n: 待编码字符的个数
 */
void huffman_coding(HuffmanTree *htree, HuffmanTable *htable, int *w, int n)
{

    if(n<=1) return; // 如果只有一个编码就相当于0
    int m = 2*n-1; // 哈夫曼树总节点数，n就是叶子结点
    *htree = (HuffmanTree) malloc((m+1) * sizeof(HTNode)); // 0号位置不用

    HuffmanTree p = *htree;

    // 初始化整棵树
    for(int i=1; i<=n; i++)
    {
        (p+i)->weight = *(w+i-1);
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }

    for(int i=n+1; i<=m; i++)
    {
        (p+i)->weight = 0;
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }


    // 建立哈夫曼树
    for(int i=n+1; i<=m; i++)
    {
        int s1, s2;
        select_min_two(*htree, i-1, &s1, &s2);
        (*htree)[s1].parent = (*htree)[s2].parent = i;
        (*htree)[i].left = s1;
        (*htree)[i].right = s2;
        (*htree)[i].weight = (*htree)[s1].weight + (*htree)[s2].weight;
    }

    // 生成哈夫曼表，从叶子到根求每个字符的哈夫曼编码
    *htable = (HuffmanTable) malloc((n+1) * sizeof(char *)); // 0号元素不用，相当于保存n个C字符串
    char *eachCode = (char *)malloc(n*sizeof(char)); // 每个字符对应的编码字符串
    eachCode[n-1] = '\0';
    for(int i=1; i<=n; i++)
    {
        int start = n-1; // 因为是逆向编码，所以要从后面填充编码字符串
        int current = i;
        int j = (*htree)[i].parent;
        // 一直寻找到根结点
        while(j != 0){
            // 如果改结点是父亲结点的左孩子则对应路径编码为0，否则为右孩子编码为1
            if((*htree)[j].left == current)
                eachCode[--start] = '0';
            else
                eachCode[--start] = '1';

            current = j;
            j = (*htree)[j].parent;
        }

        // 为第i个字符编码分配空间, n-start 表示字符数
        (*htable)[i] = (char *)malloc((n-start)*sizeof(char));
        strcpy((*htable)[i], &eachCode[start]);
    }

    free(eachCode);
}

/**
 * 打印Huffman树
 */
void print_huffman_tree(HuffmanTree htree, int n)
{
    printf("Huffman tree: \n");
    int m = 2*n-1;
    for(int i=1; i<=m; i++)
        printf("node_%d, weight = %d, parent = %d, left = %d, right = %d\n", i, htree[i].weight, htree[i].parent, htree[i].left, htree[i].right);
}

/**
 * 打印Huffman编码表中所有编码
 */
void print_all_huffman_code(HuffmanTable htable, int n)
{
    printf("Huffman code table: \n");
    for(int i=1; i<=n; i++)
        printf("%d code = %s\n", i, htable[i]);
}

int main(void)
{
    int w[5] = {2, 8, 7, 6, 5};
    int n=5;
    HuffmanTree htree;
    HuffmanTable htable;

    huffman_coding(&htree, &htable, w, n);

    print_huffman_tree(htree, n);
    print_all_huffman_code(htable, n);


    return 0;
}