写出上述赫夫曼编码的具体代码

Huffman编码是一种用于数据压缩的无损数据压缩算法，它通过构建一个最优二叉树（也称为霍夫曼树）来分配给每个字符最短的二进制码字。以下是一个简单的C++实现，使用优先队列来构建霍夫曼树：

#include <iostream>
#include <queue>
#include <unordered_map>

struct Node {
    char data;
    int freq; // 字符频率
    bool isLeaf; // 是否为叶子节点
    Node* left, *right; // 子节点指针

    Node(char d, int f) : data(d), freq(f), isLeaf(true), left(nullptr), right(nullptr) {}
};

// 优先队列模板，用于存储频率最小的节点
template<typename T>
class PriorityQueue {
public:
    struct Compare {
        bool operator()(const std::pair<T, Node*>& a, const std::pair<T, Node*>& b) {
            return a.first < b.first;
        }
    };

    void push(T value, Node* node) {
        queue<pair<T, Node*>> q({value, node});
        while (!q.empty()) {
            auto [freq, n] = q.top();
            q.pop();

            if (n->isLeaf) {
                priority_queue.push(freq, n);
            } else {
                n->left = &priority_queue.front();
                priority_queue.pop();
                n->right = &q.front();
                q.pop();
                priority_queue.push(freq, n);
            }
        }
    }

    // 取出频率最小的节点
    pair<T, Node*> top() {
        return priority_queue.top();
    }

private:
    std::priority_queue<std::pair<T, Node*>, std::vector<std::pair<T, Node*>>, Compare> priority_queue;
};

// 构建霍夫曼树并生成编码
std::unordered_map<char, std::string> huffmanCode(Node* root) {
    std::unordered_map<char, std::string> codeMap;
    buildHuffman(root, "", codeMap);
    return codeMap;
}

void buildHuffman(Node* node, std::string prefix, std::unordered_map<char, std::string>& codeMap) {
    if (node->isLeaf) {
        codeMap[node->data] = prefix;
    } else {
        buildHuffman(node->left, prefix + "0", codeMap);
        buildHuffman(node->right, prefix + "1", codeMap);
    }
}

int main() {
    // 假设有一个字符频率统计数组，这里仅示例
    int freqs[] = {5, 9, 10, 4, 6, 7};
    Node** nodes = new Node*[6];
    for (size_t i = 0; i < sizeof(freqs) / sizeof(freqs[0]); ++i) {
        nodes[i] = new Node('a' + i, freqs[i]);
    }

    PriorityQueue<Node*> pq;
    for (Node* node : nodes) {
        pq.push(node->freq, node);
    }

    Node* root = nullptr;
    while (!pq.empty()) {
        root = new Node(pq.top().second.data, pq.top().first);
        pq.pop();
        pq.push(root->freq, root);

        // 合并相邻的非叶节点
        Node* mergedNode = root;
        while (!pq.empty() && pq.top().first == mergedNode->freq) {
            mergedNode->right = pq.top().second;
            pq.pop();
            mergedNode->freq += mergedNode->right->freq;
            mergedNode->right->isLeaf = true;
        }
    }

    std::unordered_map<char, std::string> codeMap = huffmanCode(root);
    // 输出编码结果
    for (const auto& entry : codeMap) {
        std::cout << "Character '" << entry.first << "' has Huffman code " << entry.second << "\n";
    }

    // 清理内存
    for (Node* node : nodes) delete node;
    return 0;
}

这个代码首先定义了一个`Node`结构体表示霍夫曼树中的节点，然后创建了一个优先队列来构造树。`buildHuffman`函数递归地构建霍夫曼树，并在过程中生成编码。在`main`函数中，我们假设有一个字符频率数组，然后根据这些频率创建节点并插入到优先队列中。

请注意，实际应用中可能需要从文件或数据库读取字符频率，并处理动态的数据输入。以上代码仅为演示如何实现基本的Huffman编码算法。