C++代码实现哈夫曼二叉树

哈夫曼二叉树，也称为最优二叉树，通常用于数据压缩。在C++中，我们可以手动构建一个哈夫曼树，以下是一个简单的示例，使用了优先队列来实现：

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

// 定义节点结构体
struct Node {
    char data;
    int freq;
    Node* left = nullptr;
    Node* right = nullptr;

    // 构造函数
    Node(char ch, int f) : data(ch), freq(f) {}
};

// 计算频率总和
int get_freq_sum(Node* node) {
    if (node == nullptr) return 0;
    return node->freq + get_freq_sum(node->left) + get_freq_sum(node->right);
}

// 插入节点到优先队列
void insert_to.PriorityQueue(std::priority_queue<Node*, std::vector<Node*>, std::greater<Node*>>& pq, Node* node) {
    if (node != nullptr && pq.size() < 2) {
        pq.push(node);
    } else if (node != nullptr) {
        pq.push(node);
        pq.pop();
        pq.push(node);
    }
}

// 创建哈夫曼树的主函数
Node* build_Huffman_tree(std::vector<char>& freqs) {
    std::priority_queue<Node*, std::vector<Node*>, std::greater<Node*>> pq;
    for (char ch : freqs) {
        pq.push(new Node(ch, freqs[ch]));
    }

    while (pq.size() > 1) {
        Node* left = pq.top(); pq.pop();
        Node* right = pq.top(); pq.pop();

        insert_to.PriorityQueue(pq, new Node('\0', left->freq + right->freq));
        left->right = right;
        right->left = left;
    }

    return pq.top();
}

// 打印哈夫曼编码
void print_huffman_codes(Node* root, std::string code, std::unordered_map<char, std::string>& huffman_codes) {
    if (root == nullptr) return;
    print_huffman_codes(root->left, code + "0", huffman_codes);
    print_huffman_codes(root->right, code + "1", huffman_codes);

    if (root->data != '\0') {
        huffman_codes[root->data] = code;
    }
}

int main() {
    std::vector<char> freqs{'A':1, 'B':2, 'C':3}; // 示例频率数组
    Node* root = build_Huffman_tree(freqs);
    std::unordered_map<char, std::string> huffman_codes;
    print_huffman_codes(root, "", huffman_codes);
    for (auto& pair : huffman_codes) {
        std::cout << "Character " << pair.first << " has Huffman Code " << pair.second << std::endl;
    }
    return 0;
}

这个代码首先创建了一个优先队列，然后每次从队列中取出两个频率最小的节点合并成一个新的节点，直到只剩下一个节点为止。最后通过递归遍历生成的哈夫曼树来计算每个字符的编码。