C++完整代码哈夫曼编码器 给定n（n=5,n=8,n=15,n=27）个字符在某个系统中出现的概率，以该n个概率做叶子结点的权值，根据Huffman算法，构造一棵哈夫曼树，给n个字符编码。

以下是使用 C++ 实现的哈夫曼编码器完整代码：

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

using namespace std;

// 定义哈夫曼树节点结构体
struct Node {
    char ch;
    int freq;
    Node* left;
    Node* right;

    Node(char ch, int freq, Node* left = nullptr, Node* right = nullptr)
        : ch(ch), freq(freq), left(left), right(right) {}
};

// 定义比较函数，用于构建哈夫曼树
struct Compare {
    bool operator()(Node* a, Node* b) { return a->freq > b->freq; }
};

// 哈夫曼编码
void encode(Node* root, string str, unordered_map<char, string>& huffmanCode) {
    if (root == nullptr)
        return;

    // 叶子节点
    if (!root->left && !root->right) {
        huffmanCode[root->ch] = str;
    }

    encode(root->left, str + "0", huffmanCode);
    encode(root->right, str + "1", huffmanCode);
}

// 哈夫曼解码
void decode(Node* root, int& index, string str) {
    if (root == nullptr)
        return;

    // 叶子节点
    if (!root->left && !root->right) {
        cout << root->ch;
        return;
    }

    index++;
    if (str[index] == '0')
        decode(root->left, index, str);
    else
        decode(root->right, index, str);
}

// 构造哈夫曼树
Node* buildHuffmanTree(vector<pair<char, int>>& charFreq) {
    Node *left, *right, *top;
    priority_queue<Node*, vector<Node*>, Compare> minHeap;

    // 将每个字符和其出现频率保存到哈夫曼树节点中，并将节点插入最小堆中
    for (auto& p : charFreq) {
        minHeap.push(new Node(p.first, p.second));
    }

    // 构建哈夫曼树
    while (minHeap.size() > 1) {
        left = minHeap.top();
        minHeap.pop();

        right = minHeap.top();
        minHeap.pop();

        top = new Node('$', left->freq + right->freq, left, right);
        minHeap.push(top);
    }

    return minHeap.top();
}

int main() {
    int n;
    cout << "请输入字符数n：";
    cin >> n;

    vector<pair<char, int>> charFreq(n);
    cout << "请依次输入" << n << "个字符及其出现概率：" << endl;
    for (int i = 0; i < n; i++) {
        cin >> charFreq[i].first >> charFreq[i].second;
    }

    // 构建哈夫曼树
    Node* root = buildHuffmanTree(charFreq);

    // 哈夫曼编码
    unordered_map<char, string> huffmanCode;
    encode(root, "", huffmanCode);

    // 输出每个字符的哈夫曼编码
    cout << "\n字符的哈夫曼编码：" << endl;
    for (auto& p : huffmanCode) {
        cout << p.first << "：" << p.second << endl;
    }

    // 哈夫曼解码
    cout << "\n请输入要解码的字符串：";
    string str;
    cin >> str;

    int index = -1;
    cout << "解码结果：";
    while (index < (int)str.size() - 2) {
        decode(root, index, str);
    }
    cout << endl;

    return 0;
}

在输入字符及其出现概率后，程序将构建哈夫曼树，并输出每个字符的哈夫曼编码。然后，程序会要求输入要解码的字符串，并输出解码结果。