用優先佇列構造Huffman Tree及判斷是否為最優編碼的應用

前言

　　我們知道，要構造Huffman Tree，每次都要從堆中彈出最小的兩個權重的節點，然後把這兩個權重的值相加存放到新的節點中，同時讓這兩個節點分別成為新節點的左右兒子，再把新節點插入到堆中。假設節點個數為n，則重複n-1次後，最後堆中的那個節點就是Huffman Tree的根。

　　用堆實現當然可以，但是比較麻煩。你需要定義一個最小堆，堆的初始化操作，堆的插入操作，取出最小元素並調整堆的操作。先不說對這些程式碼是否熟悉掌握，當把這些函式都碼完，別人題目都已經做完了。

　　這裡我們用更方便的方法來構造一顆Huffman Tree。就是用STL中的優先佇列。其實優先佇列的本質就是一個堆。這樣我們就不需要再動手碼這麼多的函式了。同時，如果以後的題目需要用到堆這種資料結構，直接用優先佇列就可以了。

 

用優先佇列構造Huffman Tree

　　要使用優先佇列 priority_queue ，就需要包含標頭檔案 #include <queue> 。

　　樹節點的定義如下：

struct Data {
    char letter;
    int freq;
};

struct TNode {
    Data data;
    TNode *left, *right;
};

　　然後輸入字元和頻率大小，把TNode*壓入到優先佇列中。當我們需要頻率最小的頻率的那個節點，只需要從優先佇列中彈出一個元素就可以了，那個元素就是含有最小頻率的那個節點。

　　不過需要注意的是，優先佇列預設情況下是一個最大堆，這需要我們自定義一個比較函式，以實現最小堆。同時，我們比較的資料型別是我們自定義的資料型別TNode*，所以需要改成相應的資料型別。

　　這裡我們通過重寫仿函式，來實現最小堆：

class cmp {
public:
    bool operator()(TNode *a, TNode *b) {
        // 當返回true，說明a的優先順序小於b
        // 這裡用 '>' 表示，如果a節點對應的頻率大於b節點，就說明a的優先順序小於b，從而實現堆頂元素是頻率最小的那個節點，也就是最小堆
        return a->data.freq > b->data.freq;
    }
};

　　這裡我們壓入到優先佇列中的資料型別是TNode*，因此在定義優先佇列時，傳入的資料型別是TNode*。讀入資料的函式如下：

void readData(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq) {    // 傳入在main函式中定義的優先佇列 
    int n;
    scanf("%d", &n);            // 輸入節點的個數 
    for (int i = 0; i < n; i++) {
        TNode *tmp = new TNode;
        
        getchar();              // 把多餘的字元，也就是回車和空格讀掉 
        scanf("%c %d", &tmp->data.letter, &tmp->data.freq);
        tmp->left = tmp->right = NULL;
        pq.push(tmp);           // 把新節點的指標壓進優先佇列中 
    }
}

　　最後是核心程式碼，構造Huffman Tree的函式。

　　函式框架：如果優先佇列不為空，則新建一個TNode節點，彈出堆頂的元素，並讓新節點的left指向彈出這個彈出的節點。再判斷一次優先佇列是否為空；

• 如果不為空，就再彈出一個堆頂元素，並讓新節點的right指向彈出的節點。同時，把彈出的兩個節點的頻率相加的結果存放到新節點中，最後把新節點的指標壓到堆中。
• 如果為空，就說明剛剛彈出的節點就是我們要構造的Huffman Tree的根節點，只需要把它返回就可以了。

　　所以，構造Huffman Tree的函式如下：

TNode *createHuffmanTree(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq) {
    while (!pq.empty()) {           // 優先佇列不為空 
        TNode *tmp = new TNode;     // 新建一個節點 
        tmp->left = pq.top();       // 彈出堆頂元素，作為新節點的左孩子 
        pq.pop();
        
        if (!pq.empty()) {          // 剛才彈出元素後，優先佇列不為空 
            tmp->right = pq.top();  // 再彈出一個元素，作為新節點的右孩子 
            pq.pop();
            
            tmp->data.freq = tmp->left->data.freq + tmp->right->data.freq;  // 把左右孩子存放的頻率的相加結果存放到新節點中 
            pq.push(tmp);           // 把新節點的指標壓入優先佇列中 
        }
        else {                      // 否則，剛才彈出元素後，優先佇列就空了 
            return tmp->left;       // 剛才彈出的元素就是Huffman Tree的根節點，直接返回即可 
        }
    }
}

 　　現在給出完整的構造Huffman Tree的程式碼，同時計算出這顆Huffman Tree的WPL。

#include <cstdio>
#include <queue>
#include <vector>

struct Data {
    char letter;
    int freq;
};

struct TNode {
    Data data;
    TNode *left, *right;
};

class cmp {
public:
    bool operator()(TNode *a, TNode *b) { 
        return a->data.freq > b->data.freq;
    }
};

void readData(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq);
TNode *createHuffmanTree(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq);
int WPL(TNode *T, int depth);

int main() {
    std::priority_queue<TNode*, std::vector<TNode*>, cmp> pq;
    
    readData(pq);
    TNode *huffmanTree = createHuffmanTree(pq);
    printf("%d", WPL(huffmanTree, 0));
    
    return 0;
}

void readData(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq) { 
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        TNode *tmp = new TNode;
        
        getchar();
        scanf("%c %d", &tmp->data.letter, &tmp->data.freq);
        tmp->left = tmp->right = NULL;
        pq.push(tmp);
    }
}

TNode *createHuffmanTree(std::priority_queue<TNode*, std::vector<TNode*>, cmp> &pq) {
    while (!pq.empty()) {
        TNode *tmp = new TNode;
        tmp->left = pq.top();
        pq.pop();
        
        if (!pq.empty()) {
            tmp->right = pq.top();
            pq.pop();
            
            tmp->data.freq = tmp->left->data.freq + tmp->right->data.freq;
            pq.push(tmp);
        }
        else {
            return tmp->left;
        }
    }
}

int WPL(TNode *T, int depth) {
    if (T->left == NULL && T->right == NULL) return depth * T->data.freq;
    else return WPL(T->left, depth + 1) + WPL(T->right, depth + 1);
}

　　對應的Huffman Tree如下，通過檢驗WPL正是77。

 

滿足最優編碼的條件

　　我們知道，通過構造Huffman Tree而得到的編碼一定是最優編碼，但是最優編碼不一定是通過構造Huffman Tree來得到的。而且通過構造Huffman Tree得到的最優編碼是不唯一的，任意交換左右子樹的位置得到的也是最優編碼。

　　所以我們如何判斷給定的編碼是否為最優編碼？首先，我們要找到最優編碼的共同特點：

1. 最優編碼的WPL一定是最小的。
2. 無歧義解碼——字首碼：資料僅存於葉子節點。
3. 沒有度為1的節點。

　　其中如果滿足1，2這兩個條件，就一定滿足第3個條件，這個可以用反證法證明。所以，要判斷編碼是否為最優編碼，只需要檢驗編碼是否滿足1，2這兩個條件就可以了。

　　下面給出一道具體的題目，來說明如何對編碼進行1，2點的檢驗。

 

判斷編碼是否為最優編碼

　　這裡給出一道例題：Huffman Codes。題目就是給定一組字元的頻率，再給出多組字元對應的編碼，讓我們來判斷這些編碼是否為最優編碼。

原題以及更詳細的題解可以參考：https://www.cnblogs.com/onlyblues/p/14628257.html，這裡給出多種解法，有用堆去實現的，有用優先佇列實現的。

　　這裡我們用優先佇列來判斷編碼是否為最優編碼。我們只摘取題目中的測試樣例：

Sample Input:

7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11

Sample Output:

Yes
Yes
No
No

　　雖然題目看上去好像要構造一顆Huffman Tree，但實際上我們可以在整一個過程中不構造任何一顆樹，只需要用到STL中的map和priority_queue就可以完成判斷編碼是否為最優編碼。我們只需要判斷編碼是否為最優編碼，因此更多的是處理頻率這一資料。

　　先給出整一個程式框架。我們先讀入字元和對應頻率，同時把頻率壓入優先佇列形成最小堆。然後再輸入多組要判斷是否為最優編碼的資料，同時進行相應的判斷和檢測。所以我們的main函式的框架就是這樣：

int main() {
    map<char, int> letterFreq;    // 用map來儲存字元和對應的頻率，字元對映為對應的頻率 
    priority_queue< int, vector<int>, greater<int> > pq;    // 優先佇列，儲存的資料型別為int，由於預設是最大堆，所以傳入greater<int>使其變成最小堆 
    
    int n;
    cin >> n;
    readLetterFreq(letterFreq, pq, n);      // 讀入字元和頻率，同時為頻率生成最小堆的函式 
    checkOptimalCode(letterFreq, pq, n);    // 判斷多組編碼是否為最優編碼的函式 
    
    return 0;
}

　　下面來分析這兩個函式是如何實現的。首先，對於輸入的字元和對應的頻率，我們用map來儲存，形成一種對映的關係。同時在輸入字元和頻率的過程中，我們把頻率壓入優先佇列中，這樣就可以在讀入字元和頻率的過程中，也完成最小堆的構造。注意，我們壓入優先佇列的是字元頻率，所以優先佇列儲存的資料型別是int，而不再是上面的TNode*了。

　　readLetterFreq函式相關程式碼如下：

void readLetterFreq(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n) {
    for (int i = 0; i < n; i++) {
        char letter;
        getchar();                  // 讀掉多餘的字元，如回車，空格 
        cin >> letter;              // 讀入字元 
        getchar();
        cin >> letterFreq[letter];  // 讀入頻率，為字元的對映 
        
        pq.push(letterFreq[letter]);// 把讀入的頻率壓入到優先佇列中，構成最小堆 
    }
}

　　接下來我們要做的事情是計算給定字元的WPL。其實計算WPL不一定要構造一顆Huffman Tree，然後用深度乘以頻率再求和來得到。還有一種方法是把Huffman Tree中度為2的節點存放的頻率都相加起來，最後得到的結果也是WPL。這是因為葉子節點被重複計算，和用深度乘以頻率的原理基本一樣。就拿題目給的測試樣例來舉例：

　　這看上去還是要構造一顆樹啊，但實際上，如果我們用優先佇列根本不需要構造一顆樹。思路是這樣的：我們要有一個變數來累加如上圖度為2節點存放頻率。每次從優先佇列裡彈出兩個頻率，這兩個頻率是優先佇列中所包含頻率裡面最小的那兩個，然後把這兩個頻率相加，相加的結果其實就對應上圖度為2節點存放的頻率，也就是紅色的數字。然後把相加的結果累加到一個變數，同時把相加的結果壓入優先佇列中。其實這個累加的過程就是累加上圖紅色的那些數字。一直重複，直到優先佇列為空，那麼那個變數最後累加的結果就是我們要計算的WPL。

　　計算WPL的函式程式碼如下：

int getWPL(priority_queue< int, vector<int>, greater<int> > &pq) {
    int wpl = 0;                // 用來儲存累加的結果 
    while (!pq.empty()) {       // 當優先佇列不為空 
        int tmp = pq.top();     // 從優先佇列彈出一個元素，這個元素就是最小頻率 
        pq.pop();
        
        if (pq.empty()) break;  // 如果彈出那個頻元素優先佇列就為空了，退出迴圈 
        
        tmp += pq.top();        // 如果優先佇列不為空，再彈出一個元素，同時把兩個頻率進行相加 
        pq.pop();
        pq.push(tmp);           // 把兩個頻率相加的結果壓入優先佇列中 
        
        wpl += tmp;             // 同時，把這個相加結果進行累加，對應著累加度為2節點的存放頻率 
    }
    
    return wpl;
}

　　接下來我們需要對多組編碼進行檢驗。即先檢驗編碼的長度是否與給定字元頻率的WPL相同，再檢驗是否為字首碼。

　　計算每組編碼的方法很簡單，由於輸入已經給出每個字元的編碼，所以就自然知道這個字元對應編碼的長度。所以並不需要呼叫上面的getWPL函式，只需要用這個字元對應的編碼長度乘以對應的頻率就可以了。每一組編碼的WPL計算公式為：

　　再判斷codeLen是否與上面求出的給定頻率的WPL相等，如果不相等，就說明這個編碼不是最優編碼，就不需要再判斷是否為字首碼了。如果相等再去判斷是否為字首碼。

　　這裡還有個陷阱。首先我們要知道，一個最優編碼的長度是不會超過n-1的。所以如果某個編碼的長度大於n-1也說明該編碼不是最優編碼。

　　這裡先給出checkOptimalCode函式的程式碼，接下來解釋如何判斷編碼是否為字首碼。

void checkOptimalCode(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n) {
    int wpl = getWPL(pq);        // 用不構造Huffman Tree的方法來計算WPL 
    
    int m;
    cin >> m;                    // 輸入判斷編碼的組數m 
    for (int i = 0; i < m; i++) {
        string code[n];
        int codeLen = 0;
        bool ret = true;
        
        for (int i = 0; i < n; i++) {
            char letter;
            getchar();
            cin >> letter >> code[i];   // 讀入字元和對應的編碼 
            
            if (ret) {  // 如果已經知道該組編碼不是最優編碼就不需要再計算編碼長度了，但仍要繼續輸入
                if (code[i].size() > n - 1) ret = false;        // 如果某個字元的編碼長度大於n-1，說明該組編碼不是最優編碼
                codeLen += code[i].size() * letterFreq[letter]; // 計算編碼長度
            } 
        }
        
        if (ret && codeLen == wpl) {        // 如果ret == true並且編碼長度與WPL相同，才判斷該組編碼是否為字首碼
            for (int i = 0; i < n; i++) {   // 每個字元都跟它之後的字元進行判斷是否滿足字首碼的要求
                for (int j = i + 1; j < n; j++) {
                    // 判斷某個編碼是否與另外一個編碼前m個位置的相同，詳細請看圖片
                    if (code[i].substr(0, code[j].size()) == code[j].substr(0, code[i].size())) {
                        ret = false;        // 只要有一對編碼的字首相同，就說明這組的編碼不滿足字首碼
                        break;              // 後面的字元不需要判斷了，直接退出退出判斷字首碼的迴圈
                    }
                }
                if (ret == false) break;
            }
        }
        else {
            ret = false;
        }
        
        cout << (ret ? "Yes\n" : "No\n");
    }
}

　　下面來說說如何判斷編碼是否為字首碼。首先，假設現在有兩個編碼，如果這兩個編碼不滿足字首碼的話，比如"110"和"1101"，那麼其中一個編碼會與另外一個編碼前的m個位置的相同（其中m是指這兩個編碼長度中最小的那個長度）。也就是說"110"，與"1101"的前3個位置的"110"相同，就說明"110"和"1101"不滿足字首碼。

　　我們需要對同組編碼的每兩個字元進行比較，需要比較的次數為 C(n, 2) = n * (n - 1) / 2 。

　　相關的函式程式碼上面已經給出。主要是 code[i].substr(0, code[j].size()) == code[j].substr(0, code[i].size()) 這個部分。

　　 code[i].substr(0, code[j].size()) == code[j].substr(0, code[i].size()) ，這麼做始終能夠保證取到兩個編碼中，長度最小那個編碼的全部，以及另外一個編碼的前面同樣長度的部分，來進行判斷是否滿足字首碼。

　　下面給出這道題完整的AC程式碼：

#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <map>
using namespace std;

void readLetterFreq(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n);
void checkOptimalCode(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n);
int getWPL(priority_queue< int, vector<int>, greater<int> > &pq);

int main() {
    map<char, int> letterFreq;
    priority_queue< int, vector<int>, greater<int> > pq;
    
    int n;
    cin >> n;
    readLetterFreq(letterFreq, pq, n);
    checkOptimalCode(letterFreq, pq, n);
    
    return 0;
}

void readLetterFreq(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n) {
    for (int i = 0; i < n; i++) {
        char letter;
        getchar();
        cin >> letter;
        getchar();
        cin >> letterFreq[letter];
        
        pq.push(letterFreq[letter]);
    }
}

void checkOptimalCode(map<char, int> &letterFreq, priority_queue< int, vector<int>, greater<int> > &pq, int n) {
    int wpl = getWPL(pq);
    
    int m;
    cin >> m;
    for (int i = 0; i < m; i++) {
        string code[n];
        int codeLen = 0;
        bool ret = true;
        
        for (int i = 0; i < n; i++) {
            char letter;
            getchar();
            cin >> letter >> code[i];
            
            if (ret) {
                if (code[i].size() > n - 1) ret = false;
                codeLen += code[i].size() * letterFreq[letter];
            } 
        }
        
        if (ret && codeLen == wpl) {
            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (code[i].substr(0, code[j].size()) == code[j].substr(0, code[i].size())) {
                        ret = false;
                        break;
                    }
                }
                if (ret == false) break;
            }
        }
        else {
            ret = false;
        }
        
        cout << (ret ? "Yes\n" : "No\n");
    }
}

int getWPL(priority_queue< int, vector<int>, greater<int> > &pq) {
    int wpl = 0;
    while (!pq.empty()) {
        int tmp = pq.top();
        pq.pop();
        
        if (pq.empty()) break;
        
        tmp += pq.top();
        pq.pop();
        pq.push(tmp);
        
        wpl += tmp;
    }
    
    return wpl;
}

 

參考資料

　　Huffman Codes：https://www.cnblogs.com/onlyblues/p/14628257.html

　　priority_queue的用法：https://www.cnblogs.com/Deribs4/p/5657746.html