哈夫曼编码是一种基于字符出现频率进行数据压缩的最优前缀编码方法

原创于 2025-12-31 18:23:39 发布 · 274 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#算法

Method(Mentor Mechanism) 同时被 3 个专栏收录

109 篇文章

订阅专栏

OS(Operating System Commit)

103 篇文章

订阅专栏

White box tessting(Virus)

63 篇文章

订阅专栏

哈夫曼编码是一种基于字符出现频率进行数据压缩的最优前缀编码方法，其核心思想是：
为高频字符分配较短的编码，为低频字符分配较长的编码，并保证任意一个字符的编码都不是其他编码的前缀（即前缀码），从而确保译码的唯一性。

一、原理与构造过程

输入：一组字符及其对应的权值（通常为频率或概率）。
目标：构造一棵带权路径长度最短的二叉树——哈夫曼树（Huffman Tree）。
构造步骤：
1. 将每个字符作为独立的结点（权值 = 频率），构成森林。
2. 每次选出两个权值最小的根结点，合并成一个新的父结点，新结点的权值为两者之和。
3. 重复此过程，直到只剩一棵树，即哈夫曼树。
编码规则：
- 左分支标记为 0，右分支标记为 1。
- 从根到叶子的路径形成的二进制串即为该字符的哈夫曼编码。

示例解析

给定字符集 {a, b, c, d, e}，对应权值 {0.30, 0.25, 0.15, 0.22, 0.08}：

构造哈夫曼树后得到编码：
- a: 00
- b: 01
- d: 11
- c: 100
- e: 101
编码满足前缀性质，例如：
- 00 不是任何其他编码的前缀；
- 可无歧义地逐位解码：如 00101 → a, e。

二、函数补全分析（生成哈夫曼编码）

void HuffmanCoding(HuffmanTree HT, HuffmanCode HC, int n)
{
    char *cd; 
    int i, start, c, f;

    if (n <= 1) return;

    cd = (char *)malloc(n * sizeof(char));  // 临时存储编码
    cd[n-1] = '\0';  // 字符串结尾

    for (i = 1; i <= n; ++i) {
        start = n - 1;  // 从数组末尾向前写入编码
        c = i;
        f = HT[i].parent;

        // 自底向上回溯至根节点
        while (f != 0) {
            if (HT[f].lchild == c)
                cd[--start] = '0';
            else
                cd[--start] = '1';
            c = f;
            f = HT[f].parent;
        }

        // 分配空间并复制编码
        HC[i] = (char *)malloc((n - start) * sizeof(char));
        strcpy(HC[i], &cd[start]);
    }

    free(cd);  // 释放临时数组
}

函数逻辑说明：

使用动态数组 cd 临时保存从叶子到根的逆向编码序列。
回溯过程中根据当前节点是左孩子还是右孩子决定填 '0' 或 '1'。
最终将反向生成的编码正向存入 HC[i] 中（通过指针偏移实现）。
每个编码字符串独立分配内存，便于后续使用和释放。

三、结构体定义补充（常见实现）

typedef struct {
    double weight;
    int lchild, rchild, parent;
} HTNode, *HuffmanTree;

typedef char **HuffmanCode;  // 指向字符串数组的指针

HuffmanTree 是一个结构体数组，共 2n-1 个结点（n 个叶子 + n-1 个内部结点）。
HuffmanCode HC 实际上是一个 char**，HC[i] 指向第 i 个字符的编码字符串。

应用价值

哈夫曼编码广泛应用于无损数据压缩领域，如：

ZIP 压缩文件格式
JPEG 图像中的熵编码
MP3 音频压缩

它是贪心算法的经典实例：每一步选择最小权重的两棵树合并，最终获得全局最优解。

构造哈夫曼树的核心思想是贪心算法：每次选择两个权值最小的结点合并，直到所有结点合并成一棵树。这样可以保证带权路径长度（WPL）最小。

一、哈夫曼树构造算法步骤

输入：

字符集对应的权值数组 w[1..n]，共 n 个叶子结点。

输出：

一棵哈夫曼树（用结构体数组表示），包含 2n - 1 个结点。

算法步骤：

1. 初始化：
   - 创建 2n - 1 个结点的数组 HT。
   - 前 n 个结点为叶子结点，分别赋予权值 w[i]，lchild、rchild 和 parent 初始为 0。

2. 循环执行以下操作 (n - 1) 次，以构建 n - 1 个内部结点：
   a. 在当前所有“未被选作子树”的根结点中（即 parent == 0 的结点），
      找出两个权值最小的结点，记为 m1 和 m2（m1 ≤ m2）。
   b. 创建一个新的内部结点，下标为 i = n + 当前第几次合并。
   c. 设置该结点的：
        weight = m1.weight + m2.weight
        lchild = m1 下标
        rchild = m2 下标
        parent = 0
   d. 更新 m1 和 m2 的 parent 为新结点的下标。
   
3. 最终得到一棵哈夫曼树，根结点为 HT[2n-1]。

二、示例演示（简要）

设权值 {0.30, 0.25, 0.15, 0.22, 0.08}

初始 5 个叶子：a(0.3), b(0.25), d(0.22), c(0.15), e(0.08)
合并 e(0.08) 和 c(0.15) → 新结点1 (0.23)
合并 d(0.22) 和新结点1(0.23) → 新结点2 (0.45)
合并 a(0.3) 和 b(0.25) → 新结点3 (0.55)
合并新结点2(0.45) 和新结点3(0.55) → 根结点 (1.0)

最终形成哈夫曼树，根为最后一个生成的结点。

三、时间复杂度分析

方法1：使用简单遍历找最小值（适用于教学实现）

每次查找最小两个元素需扫描最多 O(n) 个结点。
共进行 n - 1 次合并，每次扫描 O(n)。
总时间复杂度：O(n²)

方法2：使用优先队列（最小堆优化）

将初始 n 个叶子插入最小堆：O(n)
每次取出两个最小元：O(log n)
插入一个合并后的新结点：O(log n)
共进行 n - 1 次操作 → O(n log n)
总时间复杂度：O(n log n)

实际应用中通常采用堆优化版本提升效率。

四、C语言伪代码（基于数组的 O(n²) 实现）

void CreateHuffmanTree(HuffmanTree &HT, int n, double w[]) {
    if (n <= 1) return;
    int m = 2 * n - 1;
    HT = (HuffmanTree)malloc(m * sizeof(HTNode));
    
    // 初始化前n个叶子结点
    for (int i = 1; i <= n; ++i) {
        HT[i].weight = w[i];
        HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }

    // 初始化内部结点（暂无连接）
    for (int i = n + 1; i <= m; ++i) {
        HT[i].weight = HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }

    // 构造内部结点
    for (int i = n + 1; i <= m; ++i) {
        int m1 = 0, m2 = 0;  // 存储最小和次小的下标
        double min1 = DBL_MAX, min2 = DBL_MAX;

        // 遍历前i-1个结点，找parent==0且权值最小的两个
        for (int j = 1; j < i; ++j) {
            if (HT[j].parent == 0 && HT[j].weight < min1) {
                min2 = min1; m2 = m1;
                min1 = HT[j].weight; m1 = j;
            } else if (HT[j].parent == 0 && HT[j].weight < min2) {
                min2 = HT[j].weight; m2 = j;
            }
        }

        // 设置新结点
        HT[m1].parent = HT[m2].parent = i;
        HT[i].lchild = m1;
        HT[i].rchild = m2;
        HT[i].weight = min1 + min2;
    }
}