一文搞懂霍夫曼树原理及C++/Python/Java实战实现

#include <iostream>
#include <queue>
#include <unordered_map>
#include <string>
using namespace std;

// 霍夫曼树节点结构
struct HuffmanNode {
    int weight;          // 节点权重（字符频率）
    char data;           // 存储字符（非叶子节点可为空）
    HuffmanNode* left;   // 左孩子
    HuffmanNode* right;  // 右孩子

    // 构造函数
    HuffmanNode(int w, char c = '\0') : weight(w), data(c), left(nullptr), right(nullptr) {}
};

// 自定义比较器：最小堆（priority_queue默认最大堆，需反向比较）
struct CompareNode {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {
        return a->weight > b->weight; // 权重小的优先出队
    }
};

// 构建霍夫曼树
HuffmanNode* buildHuffmanTree(const unordered_map<char, int>& freq) {
    // 1. 初始化最小堆，将所有字符节点入堆
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, CompareNode> minHeap;
    for (auto& pair : freq) {
        minHeap.push(new HuffmanNode(pair.second, pair.first));
    }

    // 2. 合并节点，直到堆中只剩1个节点（根节点）
    while (minHeap.size() > 1) {
        // 取出两个权重最小的节点
        HuffmanNode* left = minHeap.top();
        minHeap.pop();
        HuffmanNode* right = minHeap.top();
        minHeap.pop();

        // 合并为新节点（权重为两者之和，数据设为占位符）
        HuffmanNode* parent = new HuffmanNode(left->weight + right->weight, '#');
        parent->left = left;
        parent->right = right;

        // 新节点入堆
        minHeap.push(parent);
    }

    // 堆中剩余节点即为根节点
    return minHeap.top();
}

// 计算霍夫曼树的WPL（递归：叶子节点权重×路径长度之和）
int calculateWPL(HuffmanNode* root, int depth = 0) {
    if (root == nullptr) return 0;
    // 叶子节点（无左右孩子）：累加权重×深度
    if (root->left == nullptr && root->right == nullptr) {
        return root->weight * depth;
    }
    // 非叶子节点：递归计算左右子树WPL之和
    return calculateWPL(root->left, depth + 1) + calculateWPL(root->right, depth + 1);
}

// 生成霍夫曼编码（递归：左0右1）
void generateHuffmanCode(HuffmanNode* root, string code, unordered_map<char, string>& codeMap) {
    if (root == nullptr) return;
    // 叶子节点：记录编码
    if (root->data != '#') {
        codeMap[root->data] = code;
        return;
    }
    // 左分支加0，右分支加1
    generateHuffmanCode(root->left, code + "0", codeMap);
    generateHuffmanCode(root->right, code + "1", codeMap);
}

// 释放霍夫曼树内存（避免内存泄漏）
void destroyHuffmanTree(HuffmanNode* root) {
    if (root == nullptr) return;
    destroyHuffmanTree(root->left);
    destroyHuffmanTree(root->right);
    delete root;
}

int main() {
    // 示例：字符频率（权重）
    unordered_map<char, int> freq = {
        {'A', 5}, {'B', 9}, {'C', 12}, {'D', 13}, {'E', 16}, {'F', 45}
    };

    // 1. 构建霍夫曼树
    HuffmanNode* root = buildHuffmanTree(freq);

    // 2. 计算WPL（预期输出224）
    cout << "霍夫曼树WPL：" << calculateWPL(root) << endl;

    // 3. 生成霍夫曼编码
    unordered_map<char, string> codeMap;
    generateHuffmanCode(root, "", codeMap);
    cout << "霍夫曼编码：" << endl;
    for (auto& pair : codeMap) {
        cout << pair.first << " : " << pair.second << endl;
    }

    // 4. 释放内存
    destroyHuffmanTree(root);

    return 0;
}

import heapq

def build_huffman_tree(freq):
    """构建霍夫曼树：返回根节点（元组形式）"""
    # 1. 初始化最小堆：每个元素是(权重, 字符, 左孩子, 右孩子)
    min_heap = []
    for char, weight in freq.items():
        heapq.heappush(min_heap, (weight, char, None, None))  # 叶子节点无孩子

    # 2. 合并节点
    while len(min_heap) > 1:
        # 取出两个最小权重节点
        left_weight, left_char, left_left, left_right = heapq.heappop(min_heap)
        right_weight, right_char, right_left, right_right = heapq.heappop(min_heap)

        # 合并为新节点（权重求和，字符用占位符'#'，孩子为左右节点）
        parent_weight = left_weight + right_weight
        parent_node = (parent_weight, '#', (left_weight, left_char, left_left, left_right), (right_weight, right_char, right_left, right_right))

        # 新节点入堆
        heapq.heappush(min_heap, parent_node)

    # 返回根节点
    return min_heap[0] if min_heap else None

def calculate_wpl(root, depth=0):
    """计算WPL：递归遍历叶子节点"""
    if root is None:
        return 0
    weight, char, left, right = root
    # 叶子节点（无左右孩子）
    if left is None and right is None:
        return weight * depth
    # 非叶子节点：递归左右子树
    return calculate_wpl(left, depth + 1) + calculate_wpl(right, depth + 1)

def generate_huffman_code(root, code="", code_map=None):
    """生成霍夫曼编码：返回{字符: 编码}字典"""
    if code_map is None:
        code_map = {}
    if root is None:
        return code_map
    weight, char, left, right = root
    # 叶子节点：记录编码
    if char != '#':
        code_map[char] = code
        return code_map
    # 左0右1递归
    generate_huffman_code(left, code + "0", code_map)
    generate_huffman_code(right, code + "1", code_map)
    return code_map

if __name__ == "__main__":
    # 示例：字符频率
    freq = {'A': 5, 'B': 9, 'C': 12, 'D': 13, 'E': 16, 'F': 45}

    # 1. 构建霍夫曼树
    root = build_huffman_tree(freq)

    # 2. 计算WPL（预期224）
    print(f"霍夫曼树WPL：{calculate_wpl(root)}")

    # 3. 生成编码
    code_map = generate_huffman_code(root)
    print("霍夫曼编码：")
    for char, code in code_map.items():
        print(f"{char} : [code]")

import java.util.*;

// 霍夫曼树节点类
class HuffmanNode {
    int weight;   // 权重
    char data;    // 字符（非叶子节点为'#'）
    HuffmanNode left;  // 左孩子
    HuffmanNode right; // 右孩子

    // 构造函数
    public HuffmanNode(int weight, char data) {
        this.weight = weight;
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// 自定义比较器：按权重升序排序（最小堆）
class NodeComparator implements Comparator<HuffmanNode> {
    @Override
    public int compare(HuffmanNode a, HuffmanNode b) {
        return a.weight - b.weight; // 权重小的优先
    }
}

public class HuffmanTreeDemo {
    // 构建霍夫曼树
    public static HuffmanNode buildHuffmanTree(Map<Character, Integer> freq) {
        // 1. 初始化最小堆
        PriorityQueue<HuffmanNode> minHeap = new PriorityQueue<>(new NodeComparator());
        for (Map.Entry<Character, Integer> entry : freq.entrySet()) {
            minHeap.add(new HuffmanNode(entry.getValue(), entry.getKey()));
        }

        // 2. 合并节点
        while (minHeap.size() > 1) {
            // 取出两个最小权重节点
            HuffmanNode left = minHeap.poll();
            HuffmanNode right = minHeap.poll();

            // 合并为新节点
            HuffmanNode parent = new HuffmanNode(left.weight + right.weight, '#');
            parent.left = left;
            parent.right = right;

            // 新节点入堆
            minHeap.add(parent);
        }

        // 返回根节点
        return minHeap.peek();
    }

    // 计算WPL
    public static int calculateWPL(HuffmanNode root, int depth) {
        if (root == null) return 0;
        // 叶子节点
        if (root.left == null && root.right == null) {
            return root.weight * depth;
        }
        // 递归左右子树
        return calculateWPL(root.left, depth + 1) + calculateWPL(root.right, depth + 1);
    }

    // 生成霍夫曼编码
    public static void generateHuffmanCode(HuffmanNode root, String code, Map<Character, String> codeMap) {
        if (root == null) return;
        // 叶子节点
        if (root.data != '#') {
            codeMap.put(root.data, code);
            return;
        }
        // 左0右1
        generateHuffmanCode(root.left, code + "0", codeMap);
        generateHuffmanCode(root.right, code + "1", codeMap);
    }

    public static void main(String[] args) {
        // 示例：字符频率
        Map<Character, Integer> freq = new HashMap<>();
        freq.put('A', 5);
        freq.put('B', 9);
        freq.put('C', 12);
        freq.put('D', 13);
        freq.put('E', 16);
        freq.put('F', 45);

        // 1. 构建霍夫曼树
        HuffmanNode root = buildHuffmanTree(freq);

        // 2. 计算WPL（预期224）
        System.out.println("霍夫曼树WPL：" + calculateWPL(root, 0));

        // 3. 生成编码
        Map<Character, String> codeMap = new HashMap<>();
        generateHuffmanCode(root, "", codeMap);
        System.out.println("霍夫曼编码：");
        for (Map.Entry<Character, String> entry : codeMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}