算法基础篇：（十）贪心算法拓展之哈夫曼编码：从 “合并最优” 到数据压缩的传奇

前言

在算法世界里，贪心算法总能用最直观的 "局部最优" 策略，撬动复杂的 "全局最优" 问题。而哈夫曼编码（Huffman Coding）作为贪心算法的经典杰作，不仅完美诠释了 "每次选最小，最终得最优" 的核心思想，更在数据压缩领域写下了浓墨重彩的一笔 ------ 从早期的文件压缩到如今的多媒体传输，哈夫曼编码始终是背后的 "隐形功臣"。今天，我们就从算法原理出发，一步步拆解哈夫曼编码的设计思路、实现细节，再到实际应用，带你吃透这门 "用贪心解决最优编码" 的技术。下面就让我们正式开始吧！

一、哈夫曼编码的诞生背景：为什么需要它？

在聊算法之前，我们先思考一个实际问题：如何用更少的二进制位存储或传输数据？

比如我们有一个字符串 "AAABBBCCCD"，共 10 个字符。如果用固定长度编码 （比如每个字符用 2 位二进制表示：A=00，B=01，C=10，D=11），总长度是 10×2=20 位。但仔细观察会发现：不同字符的出现频率差异很大 ------A 出现 3 次，B 出现 3 次，C 出现 3 次，D 只出现 1 次。如果让高频字符用更短的编码，低频字符用更长的编码，是不是能减少总长度？

这就是哈夫曼编码的核心目标：根据字符出现频率，设计 "可变长度编码"，使总编码长度最小（即 "加权路径长度最小"，权重为字符频率）。而实现这一目标的关键，正是贪心算法的**"每次选择当前最优"**策略。

二、哈夫曼编码的核心原理：贪心如何实现最优？

2.1 从 "合并果子" 看哈夫曼的本质

在学习哈夫曼编码前，我们先看一道更直观的贪心例题 ------合并果子 （洛谷 P1090）：有 n 堆果子，每次只能合并两堆，消耗的体力等于两堆果子的重量之和。求合并所有果子的最小总体力。

比如有 3 堆果子，重量为 1、2、9。最优策略是：

先合并 1 和 2（体力 3），得到 3；
再合并 3 和 9（体力 12），得到 12；总体力 = 3+12=15。

为什么这样是最优的？因为每次合并重量最小的两堆，能让 "小重量" 被重复累加的次数最少。比如 1 和 2 只被累加 1 次（合并时），而 9 只被累加 1 次；如果先合并 2 和 9（体力 11），再合并 1 和 11（体力 12），总体力 = 11+12=23，明显更大 ------ 因为 2 被累加了 2 次，1 被累加了 1 次，总次数更多。

而哈夫曼编码的核心思想，与 "合并果子" 完全一致！只不过把 "果子堆" 换成了 "二叉树节点"，把 "合并体力" 换成了 "编码长度"，最终目标都是 "最小化总加权路径长度"。

2.2 哈夫曼树的构建：每次选最小，合并成新节点

哈夫曼编码的载体是哈夫曼树（最优二叉树），它是一棵带权路径长度最短的二叉树。我们先明确几个概念：

节点权重：对于字符编码问题，权重就是字符的出现频率；
路径长度：从根节点到某一节点的边数；
加权路径长度：所有叶子节点的 "权重 × 路径长度" 之和（对应编码总长度）。

哈夫曼树的构建步骤（以字符频率为例）：

初始化：将每个字符作为一个 "叶子节点"，权重为其出现频率，放入一个优先队列（小根堆，用于快速获取最小权重节点）；
合并节点：从优先队列中取出权重最小的两个节点，构建一个新的父节点，父节点的权重为两个子节点的权重之和；
入队新节点：将新父节点放入优先队列；
重复步骤 2-3：直到优先队列中只剩下一个节点（这个节点就是哈夫曼树的根节点）。

举个例子：构建 "AAABBBCCCD" 的哈夫曼树

字符频率：A (3)、B (3)、C (3)、D (1)步骤 1：初始化小根堆，节点为 [D (1), A (3), B (3), C (3)]；步骤 2：取出最小的两个节点 D (1) 和 A (3)，合并为父节点 E (4)，堆变为 [B (3), C (3), E (4)]；步骤 3：取出最小的两个节点 B (3) 和 C (3)，合并为父节点 F (6)，堆变为 [E (4), F (6)]；步骤 4：取出 E (4) 和 F (6)，合并为根节点 G (10)，堆中只剩根节点，构建完成。

最终哈夫曼树的结构如下（左子树为 0，右子树为 1，编码由根到叶子的路径决定）：

G (10) 左孩子 E (4)，右孩子 F (6)；
E (4) 左孩子 D (1)（编码 00），右孩子 A (3)（编码 01）；
F (6) 左孩子 B (3)（编码 10），右孩子 C (3)（编码 11）。

此时总编码长度 =（D 的频率 × 编码长度）+（A 的频率 × 编码长度）+（B 的频率 × 编码长度）+（C 的频率 × 编码长度）= 1×2 + 3×2 + 3×2 + 3×2 = 20？不对，这和固定编码一样？哦，因为这个例子中频率分布较均匀，我们换一个更极端的例子：

例子 2：字符频率 A (5)、B (9)、C (12)、D (13)、E (16)、F (45)

按照步骤构建哈夫曼树后，高频字符 F 的编码长度为 1（路径最短），低频字符 A 的编码长度为 4（路径最长），总编码长度会远小于固定编码（固定编码需 3 位 / 字符，总长度 = 5×3+9×3+12×3+13×3+16×3+45×3= 300；哈夫曼编码总长度 = 5×4+9×4+12×3+13×3+16×2+45×1= 224，减少 25%）。

这就是哈夫曼编码的优势：高频字符用短编码，低频字符用长编码，总长度最小。

2.3 哈夫曼编码的特性：为什么不会出现二义性？

有人可能会问：可变长度编码会不会出现 "一个编码是另一个编码的前缀" 的情况？比如 A=0，B=01，那么 "01" 既可以是 B，也可以是 A+1（假设 1 是其他字符），导致解码歧义。

而哈夫曼树的结构完美解决了这个问题：所有字符都在叶子节点上。叶子节点没有子节点，因此任何一个字符的编码都不会是另一个字符编码的前缀 ------ 比如 A 的编码是 00，B 的编码是 01，C 的编码是 10，D 的编码是 11，没有任何一个编码是其他编码的前缀，解码时只需从根节点出发，遇到 0 走左子树，遇到 1 走右子树，直到叶子节点，就能唯一确定字符。

三、哈夫曼编码的实现：从理论到代码

哈夫曼编码的实现分为两步：构建哈夫曼树 和生成编码 / 解码。我们以 "统计字符串中字符频率，生成哈夫曼编码，并计算总编码长度" 为例，用 C++ 实现完整流程。

3.1 数据结构选择：小根堆（优先队列）

构建哈夫曼树的核心是 "每次获取权重最小的两个节点"，因此需要一个高效的数据结构来维护节点集合。C++ 中的priority_queue（优先队列）默认是大根堆，我们可以通过自定义比较函数，将其改为小根堆。

对于节点，我们需要存储：

权重（字符频率）；

左子节点和右子节点（构建树结构）；

字符（仅叶子节点需要）。

因此，我们定义一个HuffmanNode结构体：

cpp 复制代码

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

// 哈夫曼树节点结构体
struct HuffmanNode {
    int weight;         // 权重（字符频率）
    char ch;            // 字符（仅叶子节点有效）
    HuffmanNode* left;  // 左子节点
    HuffmanNode* right; // 右子节点

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

// 小根堆的比较函数（权重小的节点优先）
struct Compare {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {
        return a->weight > b->weight;
    }
};

3.2 步骤 1：统计字符频率

首先，我们需要遍历输入字符串，统计每个字符的出现频率，用unordered_map存储（字符→频率）。

cpp 复制代码

// 统计字符频率
unordered_map<char, int> countFrequency(const string& s) {
    unordered_map<char, int> freq;
    for (char c : s) {
        freq[c]++;
    }
    return freq;
}

3.3 步骤 2：构建哈夫曼树

根据字符频率，初始化小根堆，然后循环合并节点，直到堆中只剩一个节点（根节点）。

cpp 复制代码

// 构建哈夫曼树，返回根节点
HuffmanNode* buildHuffmanTree(const unordered_map<char, int>& freq) {
    // 1. 初始化小根堆，将每个字符作为叶子节点入队
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> heap;
    for (auto& pair : freq) {
        char c = pair.first;
        int weight = pair.second;
        heap.push(new HuffmanNode(weight, c));
    }

    // 2. 特殊情况：如果只有一个字符（避免循环不执行）
    if (heap.size() == 1) {
        HuffmanNode* singleNode = heap.top();
        heap.pop();
        HuffmanNode* root = new HuffmanNode(singleNode->weight);
        root->left = singleNode;
        heap.push(root);
    }

    // 3. 合并节点，构建哈夫曼树
    while (heap.size() > 1) {
        // 取出权重最小的两个节点
        HuffmanNode* left = heap.top();
        heap.pop();
        HuffmanNode* right = heap.top();
        heap.pop();

        // 构建新的父节点（权重为两个子节点之和，字符为空）
        HuffmanNode* parent = new HuffmanNode(left->weight + right->weight);
        parent->left = left;
        parent->right = right;

        // 将父节点入队
        heap.push(parent);
    }

    // 4. 堆中剩余的节点就是根节点
    return heap.top();
}

3.4 步骤 3：生成哈夫曼编码（递归 / 迭代）

生成编码的过程，就是遍历哈夫曼树，从根节点到叶子节点，左子树记为 0，右子树记为 1，记录路径上的 0 和 1，即为该叶子节点字符的编码。我们用unordered_map<char, string>存储（字符→编码）。

这里采用递归方式遍历树：

cpp 复制代码

// 生成哈夫曼编码（递归遍历哈夫曼树）
void generateHuffmanCode(HuffmanNode* root, string code, unordered_map<char, string>& huffCode) {
    // 递归终止条件：叶子节点（左子树和右子树都为空）
    if (root->left == nullptr && root->right == nullptr) {
        huffCode[root->ch] = code;
        return;
    }

    // 左子树：路径加"0"
    if (root->left != nullptr) {
        generateHuffmanCode(root->left, code + "0", huffCode);
    }

    // 右子树：路径加"1"
    if (root->right != nullptr) {
        generateHuffmanCode(root->right, code + "1", huffCode);
    }
}

3.5 步骤 4：编码字符串与计算总长度

根据生成的哈夫曼编码，将输入字符串转换为二进制编码，并计算总编码长度（验证是否最优）。

cpp 复制代码

// 编码字符串：将输入字符串转换为哈夫曼编码
string encodeString(const string& s, const unordered_map<char, string>& huffCode) {
    string encoded;
    for (char c : s) {
        encoded += huffCode.at(c); // at() 会检查键是否存在，避免错误
    }
    return encoded;
}

// 计算总编码长度
long long calculateTotalLength(const unordered_map<char, int>& freq, const unordered_map<char, string>& huffCode) {
    long long total = 0;
    for (auto& pair : freq) {
        char c = pair.first;
        int count = pair.second;
        int codeLength = huffCode.at(c).size();
        total += (long long)count * codeLength;
    }
    return total;
}

3.6 步骤 5：解码哈夫曼编码（从二进制到字符串）

解码过程是编码的逆过程：从根节点出发，根据二进制位（0→左子树，1→右子树）遍历树，直到叶子节点，取出字符，然后重新从根节点开始，直到所有二进制位处理完毕。

cpp 复制代码

// 解码哈夫曼编码：将二进制编码转换为原始字符串
string decodeString(const string& encoded, HuffmanNode* root) {
    string decoded;
    HuffmanNode* current = root; // 从根节点开始遍历

    for (char bit : encoded) {
        // 0 走左子树，1 走右子树
        if (bit == '0') {
            current = current->left;
        } else {
            current = current->right;
        }

        // 到达叶子节点，取出字符，重置current为根节点
        if (current->left == nullptr && current->right == nullptr) {
            decoded += current->ch;
            current = root;
        }
    }

    return decoded;
}

3.7 步骤 6：释放哈夫曼树内存（避免内存泄漏）

哈夫曼树是动态分配的节点，使用完毕后需要手动释放内存，避免内存泄漏。

cpp 复制代码

// 释放哈夫曼树内存（后序遍历）
void freeHuffmanTree(HuffmanNode* root) {
    if (root == nullptr) {
        return;
    }
    // 先释放左子树和右子树
    freeHuffmanTree(root->left);
    freeHuffmanTree(root->right);
    // 再释放当前节点
    delete root;
}

3.8 完整测试代码

我们用 "AAABBBCCCD" 和 "AAAAABBBBBCCCCDDEEEEE" 两个例子测试代码：

cpp 复制代码

int main() {
    // 测试用例1：字符串 "AAABBBCCCD"
    string s1 = "AAABBBCCCD";
    cout << "=== 测试用例1：" << s1 << " ===" << endl;

    // 1. 统计频率
    unordered_map<char, int> freq1 = countFrequency(s1);
    cout << "字符频率：" << endl;
    for (auto& pair : freq1) {
        cout << pair.first << ": " << pair.second << endl;
    }

    // 2. 构建哈夫曼树
    HuffmanNode* root1 = buildHuffmanTree(freq1);

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

    // 4. 编码字符串
    string encoded1 = encodeString(s1, huffCode1);
    cout << "编码结果：" << encoded1 << endl;

    // 5. 计算总编码长度
    long long totalLen1 = calculateTotalLength(freq1, huffCode1);
    cout << "总编码长度：" << totalLen1 << endl;

    // 6. 解码字符串
    string decoded1 = decodeString(encoded1, root1);
    cout << "解码结果：" << decoded1 << endl;

    // 释放内存
    freeHuffmanTree(root1);
    cout << endl;

    // 测试用例2：字符串 "AAAAABBBBBCCCCDDEEEEE"
    string s2 = "AAAAABBBBBCCCCDDEEEEE";
    cout << "=== 测试用例2：" << s2 << " ===" << endl;

    unordered_map<char, int> freq2 = countFrequency(s2);
    cout << "字符频率：" << endl;
    for (auto& pair : freq2) {
        cout << pair.first << ": " << pair.second << endl;
    }

    HuffmanNode* root2 = buildHuffmanTree(freq2);
    unordered_map<char, string> huffCode2;
    generateHuffmanCode(root2, "", huffCode2);
    cout << "哈夫曼编码：" << endl;
    for (auto& pair : huffCode2) {
        cout << pair.first << ": " << pair.second << endl;
    }

    string encoded2 = encodeString(s2, huffCode2);
    cout << "编码结果：" << encoded2 << endl;

    long long totalLen2 = calculateTotalLength(freq2, huffCode2);
    cout << "总编码长度：" << totalLen2 << endl;

    string decoded2 = decodeString(encoded2, root2);
    cout << "解码结果：" << decoded2 << endl;

    freeHuffmanTree(root2);

    return 0;
}

3.9 代码输出与分析

测试用例 1 输出：

复制代码

=== 测试用例1：AAABBBCCCD ===
字符频率：
A: 3
B: 3
C: 3
D: 1
哈夫曼编码：
D: 00
A: 01
B: 10
C: 11
编码结果：01010110101011111100
总编码长度：20
解码结果：AAABBBCCCD

分析：由于 4 个字符频率较均匀（3,3,3,1），哈夫曼编码长度均为 2 位，总长度 20，与固定编码一致，但如果频率差异更大，优势会更明显。

测试用例 2 输出：

复制代码

=== 测试用例2：AAAAABBBBBCCCCDDEEEEE ===
字符频率：
A: 6
B: 5
C: 4
D: 2
E: 5
哈夫曼编码：
D: 000
C: 001
B: 01
E: 10
A: 11
编码结果：111111110101010101001001001001000000101010101010
总编码长度：49
解码结果：AAAAABBBBBCCCCDDEEEEE

分析：高频字符 A（6 次）编码为 2 位，低频字符 D（2 次）编码为 3 位，总长度 49。如果用固定编码（3 位 / 字符，共 22 个字符），总长度 = 22×3=66，哈夫曼编码减少了 26% 的长度，优势显著。

四、哈夫曼编码的实际应用：不止于 "编码"

哈夫曼编码的核心是**"最小化加权路径长度"** ，这一思想不仅用于数据压缩，还广泛应用于其他需要**"最优分配"** 的场景。

4.1 数据压缩领域

文件压缩：ZIP、GZIP 等压缩格式的核心算法之一就是哈夫曼编码，结合 LZ77/LZ78 等算法，实现高效压缩；
图像压缩：JPEG 图像压缩中，对 DCT 变换后的系数进行哈夫曼编码，减少存储容量；
音频压缩：MP3 音频压缩中，对量化后的音频数据进行哈夫曼编码，降低比特率。

4.2 其他领域的拓展应用

应用 1：最优合并问题（如合并果子）

前面提到的 "合并果子" 问题，本质就是哈夫曼编码的变种 ------ 将 "合并体力" 视为 "路径长度"，"果子堆重量" 视为 "节点权重"，最优合并策略与哈夫曼树构建完全一致。

应用 2：任务调度（最小化总等待时间）

有 n 个任务，每个任务的处理时间为 ti，每次只能处理一个任务，求所有任务的总等待时间最小。策略是 "每次选择处理时间最短的任务"，与哈夫曼的 "每次选最小" 思想一致，能让短任务被等待的次数最少。

应用 3：通信领域（差错控制）

在计算机网络的通信领域中，哈夫曼编码可用于**"差错控制编码"**------ 对高频出现的错误模式分配更短的纠错编码，减少纠错开销，提高通信效率。

五、哈夫曼编码的优化与注意事项

5.1 优化：处理 "频率为 0" 或 "单个字符" 的情况

单个字符：如果输入字符串只有一种字符（如 "AAAAA"），构建哈夫曼树时会出现 "堆中只有一个节点" 的情况，此时需要手动构建一个父节点，将该字符作为左子节点，避免递归生成编码时出错（代码中已处理此情况）；
频率为 0：实际应用中，字符频率为 0 的无需加入哈夫曼树，减少节点数量，提高效率。

5.2 注意事项：数据溢出问题

在计算总编码长度或节点权重时，若字符频率较大（如 1e9）或字符数量较多（如 1e5），权重之和可能超过int范围，因此必须使用long long类型（代码中已用long long计算总长度）。

5.3 优化：哈夫曼编码的存储

生成的哈夫曼编码是二进制字符串，但计算机存储的是字节（8 位），因此需要将二进制编码 "打包" 成字节，比如每 8 位组成一个字节，最后不足 8 位的用 0 填充，并记录填充位数，以便解码时恢复。

例如，编码 "0101011010"（10 位），可打包为两个字节：01010110（第 1 字节）和 10000000（第 2 字节，填充 6 个 0），并记录填充位数 6，解码时去掉最后 6 个 0 即可。

总结

哈夫曼编码的本质，是用 "贪心策略" 实现 "最小化加权路径长度"，它告诉我们：在解决复杂的最优问题时，不必追求全局最优的直接解法，而是通过每次选择当前最优的局部解，最终就能得到全局最优解。

哈夫曼编码不仅是一种算法，更是一种解决问题的思路 ------ 当你遇到 "需要最小化总代价" 且 "代价与权重和路径相关" 的问题时，不妨想想：能不能用哈夫曼的思想，每次选最小的合并？

最后，算法学习的关键在于 "举一反三"。建议你尝试用哈夫曼思想解决 "合并果子""最优任务调度" 等问题，加深对 "每次选最小，最终得最优" 的理解。如果在实现过程中遇到问题，不妨回到本文的代码，对比思路，找到问题所在。祝你在算法的道路上，用贪心的智慧，破解更多难题！

算法基础篇：（十）贪心算法拓展之哈夫曼编码：从 “合并最优” 到数据压缩的传奇

目录

前言

一、哈夫曼编码的诞生背景：为什么需要它？

二、哈夫曼编码的核心原理：贪心如何实现最优？

2.1 从 "合并果子" 看哈夫曼的本质

2.2 哈夫曼树的构建：每次选最小，合并成新节点

举个例子：构建 "AAABBBCCCD" 的哈夫曼树

例子 2：字符频率 A (5)、B (9)、C (12)、D (13)、E (16)、F (45)

2.3 哈夫曼编码的特性：为什么不会出现二义性？

三、哈夫曼编码的实现：从理论到代码

3.1 数据结构选择：小根堆（优先队列）

3.2 步骤 1：统计字符频率

3.3 步骤 2：构建哈夫曼树

3.4 步骤 3：生成哈夫曼编码（递归 / 迭代）

3.5 步骤 4：编码字符串与计算总长度

3.6 步骤 5：解码哈夫曼编码（从二进制到字符串）

3.7 步骤 6：释放哈夫曼树内存（避免内存泄漏）

3.8 完整测试代码

3.9 代码输出与分析

测试用例 1 输出：

测试用例 2 输出：

四、哈夫曼编码的实际应用：不止于 "编码"

4.1 数据压缩领域

4.2 其他领域的拓展应用

应用 1：最优合并问题（如合并果子）

应用 2：任务调度（最小化总等待时间）

应用 3：通信领域（差错控制）

五、哈夫曼编码的优化与注意事项

5.1 优化：处理 "频率为 0" 或 "单个字符" 的情况

5.2 注意事项：数据溢出问题

5.3 优化：哈夫曼编码的存储

总结