问题 A: 算法6-12：自底向上的赫夫曼编码

1 题目

在通讯领域，经常需要将需要传送的文字转换成由二进制字符组成的字符串。在实际应用中，由于总是希望被传送的内容总长尽可能的短，如果对每个字符设计长度不等的编码，且让内容中出现次数较多的字符采用尽可能短的编码，则整个内容的总长便可以减少。另外，需要保证任何一个字符的编码都不是另一个字符的编码前缀，这种编码成为前缀编码。
而赫夫曼编码就是一种二进制前缀编码，其从叶子到根（自底向上）逆向求出每个字符。

在本题中，读入n个字符所对应的权值，生成赫夫曼编码，并依次输出计算出的每一个赫夫曼编码。

输入
输入的第一行包含一个正整数n，表示共有n个字符需要编码。其中n不超过100。
第二行中有n个用空格隔开的正整数，分别表示n个字符的权值。
输出
共n行，每行一个字符串，表示对应字符的赫夫曼编码。

样例输入 
8
5 29 7 8 14 23 3 11
样例输出 
0110
10
1110
1111
110
00
0111
010

2 代码

#include <cstdio>
#include <cstring>
#include <limits.h>
#include <algorithm>
#include <iostream>

using std::swap;
using  std::strcpy;

typedef char *HuffmanCode;

const int MAXN = 110;

typedef struct{
    int weight;
    int lchild, rchild, parent;
}HuffmanNode, *HuffmanTree;

void seletMin(HuffmanTree HT, int n, int &s1, int &s2){
    int min = INT32_MAX;
    for (int i = 1; i <= n; ++i) {
        if(HT[i].parent == 0 && min > HT[i].weight){
            min = HT[i].weight;
            s1 = i;
        }
    }

    min = INT32_MAX;
    for (int j = 1; j <= n; ++j) {
        if(HT[j].parent == 0 && min > HT[j].weight && j != s1){
            min = HT[j].weight;
            s2 = j;
        }
    }

    if(s1 > s2){
        swap(s1, s2);
    }

}

void HuffmanCoding(HuffmanTree &HT, HuffmanCode *&HC,int w[],int n){
    // w存放n个字符的权值（均>0）,构造哈夫曼树HT，并求出n个字符的哈夫曼树编码HC
    if(n <= 1) return;
    int m = 2 * n -1;
    //0号单元未用
    HT = new HuffmanNode[m + 1];

    for (int i = 1; i <= n; ++i) {
        HT[i].weight = w[i];
        HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }

    for (int i = n + 1; i<= m; ++i) {
        HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }


    for (int i = n + 1; i <= m; ++i)//建立哈夫曼树
    {
        int s1, s2;
        //在HT[1~i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1,s2
        seletMin(HT, i - 1, s1, s2);
        HT[s1].parent = HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;

    }
    //从叶结点到根你想求每个字符的哈夫曼编码
    HC = new HuffmanCode[n + 1];
    //分配n个字符编码的头指针向量([0]不用)
    char* cd = new char[n];//分配编码工作空间

    cd[n - 1] = '\0';//编码结束符

    for (int i = 1; i <= n; ++i)//逐个字符求哈夫曼编码
    {
        int star = n - 1;//编码结束位置
        for (int c = i, f = HT[i].parent;f != 0; c = f, f = HT[f].parent)
        {
            //从叶结点到根逆向求编码
            if(HT[f].lchild == c){
                cd[--star] = '0';
            }else{
                cd[--star] = '1';
            }
        }
            //为第i个字符串编码分配空间
            HC[i] = new char[n - star];
            //从cd复制编码（串）到HC
            strcpy(HC[i], cd + star);
    }
    delete []cd;//释放工作空间
}

int main(){
    HuffmanTree HT;
    HuffmanCode *HC;
    int n;
    int data[MAXN];

    while(scanf("%d", &n) != EOF){
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &data[i]);
        }

        HuffmanCoding(HT, HC, data, n);

        for (int j = 1; j <= n; ++j) {
            //printf("%s\n", HC[j]);
            std::cout << HC[j] << std::endl;
        }

        delete(HT);
        delete(HC);
    }

    return 0;
}
/*
Input:
8
5 29 7 8 14 23 3 11
Output:
0110
10
1110
1111
110
00
0111
010
 */