使用优先级队列的霍夫曼编码

先决条件：贪婪算法|在C++ STL中设置3(霍夫曼编码)，priority_queue :: push()和priority_queue :: pop()
给定一个char数组ch [] ，每个字符的频率为freq [] 。任务是使用优先级队列为ch []中的每个字符查找霍夫曼代码。

例子

Input: ch[] = { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ }, freq[] = { 5, 9, 12, 13, 16, 45 }
Output:
f 0
c 100
d 101
a 1100
b 1101
e 111

方法：

1. 将ch []中的所有字符推送到优先级队列中对应的频率freq [] 。
2. 要创建霍夫曼树，请从优先级队列中弹出两个节点。
3. 将优先级队列中的两个弹出节点分配为新节点的左子节点和右子节点。
4. 推送在优先级队列中形成的新节点。
5. 重复上述所有步骤，直到优先级队列的大小变为1。
6. 遍历霍夫曼树(其根是优先级队列中剩下的唯一节点)以存储霍夫曼代码

   对于ch []中的每个字符。

7. 为ch []中的每个字符打印所有存储的霍夫曼代码。

下面是上述方法的实现：

// C++ Program for Huffman Coding
// using Priority Queue
#include 
#include 
using namespace std;
  
// Maximum Height of Huffman Tree.
#define MAX_SIZE 100
  
class HuffmanTreeNode {
public:
    // Stores character
    char data;
  
    // Stores frequency of
    // the character
    int freq;
  
    // Left child of the
    // current node
    HuffmanTreeNode* left;
  
    // Right child of the
    // current node
    HuffmanTreeNode* right;
  
    // Initializing the
    // current node
    HuffmanTreeNode(char character,
                    int frequency)
    {
        data = character;
        freq = frequency;
        left = right = NULL;
    }
};
  
// Custom comparator class
class Compare {
public:
    bool operator()(HuffmanTreeNode* a,
                    HuffmanTreeNode* b)
    {
        // Defining priority on
        // the basis of frequency
        return a->freq > b->freq;
    }
};
  
// Function to generate Huffman
// Encoding Tree
HuffmanTreeNode* generateTree(priority_queue,
                                             Compare> pq)
{
  
    // We keep on looping till
    // only one node remains in
    // the Priority Queue
    while (pq.size() != 1) {
  
        // Node which has least
        // frequency
        HuffmanTreeNode* left = pq.top();
  
        // Remove node from
        // Priority Queue
        pq.pop();
  
        // Node which has least
        // frequency
        HuffmanTreeNode* right = pq.top();
  
        // Remove node from
        // Priority Queue
        pq.pop();
  
        // A new node is formed
        // with frequency left->freq
        // + right->freq
  
        // We take data as '$'
        // because we are only
        // concerned with the
        // frequency
        HuffmanTreeNode* node = new HuffmanTreeNode('$',
                                  left->freq + right->freq);
        node->left = left;
        node->right = right;
  
        // Push back node
        // created to the
        // Priority Queue
        pq.push(node);
    }
  
    return pq.top();
}
  
// Function to print the
// huffman code for each
// character.
  
// It uses arr to store the codes
void printCodes(HuffmanTreeNode* root,
                int arr[], int top)
{
    // Assign 0 to the left node
    // and recur
    if (root->left) {
        arr[top] = 0;
        printCodes(root->left,
                   arr, top + 1);
    }
  
    // Assign 1 to the right
    // node and recur
    if (root->right) {
        arr[top] = 1;
        printCodes(root->right, arr, top + 1);
    }
  
    // If this is a leaf node,
    // then we print root->data
  
    // We also print the code
    // for this character from arr
    if (!root->left && !root->right) {
        cout << root->data << " ";
        for (int i = 0; i < top; i++) {
            cout << arr[i];
        }
        cout << endl;
    }
}
  
void HuffmanCodes(char data[],
                  int freq[], int size)
{
  
    // Declaring priority queue
    // using custom comparator
    priority_queue,
                   Compare>
        pq;
  
    // Populating the priority
    // queue
    for (int i = 0; i < size; i++) {
        HuffmanTreeNode* newNode
            = new HuffmanTreeNode(data[i], freq[i]);
        pq.push(newNode);
    }
  
    // Generate Huffman Encoding
    // Tree and get the root node
    HuffmanTreeNode* root = generateTree(pq);
  
    // Print Huffman Codes
    int arr[MAX_SIZE], top = 0;
    printCodes(root, arr, top);
}
  
// Driver Code
int main()
{
    char data[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
    int freq[] = { 5, 9, 12, 13, 16, 45 };
    int size = sizeof(data) / sizeof(data[0]);
  
    HuffmanCodes(data, freq, size);
    return 0;
}

输出：

f 0
c 100
d 101
a 1100
b 1101
e 111

时间复杂度：O(n * logn)其中n是唯一字符的数量