《数据结构与算法分析：C语言描述》复习——第十章“算法设计技巧”——Huffman编码

2014.07.06 16:47

简介：

　　给定一段有固定符号集合S构成的文本T，集合S中总共有n种符号。如果对于每种符号，使用一种不同的由‘0’和‘1’构成的位字符串来代替，比如：

　　　　‘a’->‘01’

　　　　‘c’->'101'

　　　　'd'->‘11’

　　　　...

　　例如，文本“acd”经过这种编码就变成了“0110111”。

　　这样，就可以把文本T中的符号全部替换为‘0’‘1’构成的二进制串，这样就能以二进制文件的形式保存信息了。并且，一个ASCII字符默认占用一个字节，也就是8位。但使用这种不定长的编码方式一个字符占用的位数可能小于8位，于是可能达到压缩数据的效果。Huffman编码的规则，就是通过选定合适的编码，使得这段文本经过编码转换后的二进制串的长度最短。

图示：

　　用算法描述Huffman编码的过程还是比较简单的：

　　1. 定义键值对<字符, 出现频率>，比如<a, 12>表示a字符出现了12次。

　　

　　2. 每次选出出现频率最低的两个字符，组合成一个字符（字符当然不能组合，但频率是可以相加的），重新放入候选集中。

　　

　　3. 这个组合的过程，其实就是构建二叉树的过程

　　

　　新结点的频率等于两个子节点的频率之和，而新节点上对应的字符没有实际意义，所以我们姑且标记为‘?’。

　　每经过一轮这样的操作，我们取出两个结点，放回一个结点，所以要经过n-1轮才能得到一棵完整的树，比如这样：

　　

　　上图中给出了这棵树对应的字符编码方式，其实每个字符的编码对应于从根结点到叶结点的路径，‘0’向左，‘1’向右。

　　由于组合两个结点时，左右次序可以调换，因此同一套文本与字符可以构建出2^(n-1)种的Huffman树。任何一种的效果都是相同的，目的只有一个：压缩数据。

　　如何每次选出最小的两个呢？最小堆。

　　问题是：为什么每次选出最小的，结果就是最好的呢？贪婪。

实现：

// A simple illustration for 
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

// The character statistics type
typedef unordered_map<char, int> StatType;
// The character encoding type
typedef unordered_map<char, string> EncodeType;

struct TreeNode {
    char ch;
    int weight;
    TreeNode *left;
    TreeNode *right;
    
    TreeNode(char _ch, int _weight): ch(_ch), weight(_weight), 
        left(nullptr), right(nullptr) {}
};

struct GreaterFunctor {
    bool operator () (const TreeNode *x, const TreeNode *y) {
        return x->weight > y->weight;
    }
};

void deleteTree(TreeNode *&root)
{
    if (root == nullptr) {
        return;
    } else {
        deleteTree(root->left);
        deleteTree(root->right);
        delete root;
        root = nullptr;
    }
}

void calculateEncoding(const TreeNode *root, EncodeType &encoding, string &path)
{
    if (root == nullptr) {
        return;
    }
    
    if (root->ch != '\0') {
        encoding[root->ch] = path;
        return;
    }
    
    path.push_back('0');
    calculateEncoding(root->left, encoding, path);
    path.pop_back();
    
    path.push_back('1');
    calculateEncoding(root->right, encoding, path);
    path.pop_back();
}

void huffmanEncoding(const StatType &statistics, EncodeType &encoding)
{
    priority_queue<TreeNode *, vector<TreeNode *>, GreaterFunctor> pq;
    
    int n;
    
    n = 0;
    for (StatType::const_iterator sta_it = statistics.begin(); 
        sta_it != statistics.end(); ++sta_it) {
        pq.push(new TreeNode(sta_it->first, sta_it->second));
        ++n;
    }
    
    TreeNode *p1, *p2, *p3;
    int i;
    for (i = 0; i < n - 1; ++i) {
        p1 = pq.top();
        pq.pop();
        p2 = pq.top();
        pq.pop();
        
        p3 = new TreeNode('\0', p1->weight + p2->weight);
        p3->left = p1;
        p3->right = p2;
        pq.push(p3);
    }
    
    TreeNode *root = pq.top();
    pq.pop();
    
    string code = "";
    calculateEncoding(root, encoding, code);
    deleteTree(root);
}

int main()
{
    int i, n;
    string s;
    int weight;
    StatType statistics;
    EncodeType encoding;
    
    while (cin >> n && n > 0) {
        for (i = 0; i < n; ++i) {
            cin >> s >> weight;
            statistics[s[0]] = weight;
        }
        huffmanEncoding(statistics, encoding);
        
        for (EncodeType::const_iterator enc_it = encoding.begin(); 
            enc_it != encoding.end(); ++enc_it) {
            cout << enc_it->first << ':' << enc_it->second << endl;
        }
        cout << endl;

        statistics.clear();
        encoding.clear();
    }
    
    return 0;
}