哈夫曼编码与哈夫曼树（C语言实现）

最新推荐文章于 2023-12-06 23:47:11 发布

卷不动硬卷

最新推荐文章于 2023-12-06 23:47:11 发布

阅读量881

点赞数 3

分类专栏：数据结构文章标签： c语言数据结构霍夫曼树

本文链接：https://blog.csdn.net/zhao_Tao_WA/article/details/131614503

版权

数据结构专栏收录该内容

4 篇文章 1 订阅

订阅专栏

文章介绍了哈夫曼编码的概念，通过对比定长编码（如ASCII编码）和变长编码（如UTF-8编码），阐述了变长编码在数据传输中的优势。在特定场景下，哈夫曼编码能通过构建最优的二叉树结构，根据字符出现概率生成编码，从而降低平均编码长度，提高传输效率。文章还提供了C语言实现哈夫曼树和编码的代码示例。

摘要由CSDN通过智能技术生成

哈夫曼编码与哈夫曼树（C语言实现）

什么是编码

定长编码

在ASCII编码里，字符 ‘a’ = 97 = (0110 0001)₂，字符 ‘0’ = 48 = (0011 0000)₂

那么有这么一条信息，“aa00”，通过ASCII编码的二进制来表示的话就等于 “01100001、01100001、00110000、00110000”，一台计算机传输到另一台计算机，面对当前这个"aa00"这个信息，就需要传输32个比特位

假设计算机的网络是32 bit / s，所用时：1s

特定场景：只有a，b，0，1四种字符需要传输，那么我们需要用ASCII编码吗？

我们完全可以这么设计a：00，b：01，0：10，1：11，那么在面对"aa00"这个信息的时候，就可以这么表示"00001010"，假设在带宽不变的情况下，只需要传输0.25s

以上的编码，都是定长编码（对于每一个字符，编码长度相同，这就是定长编码，例如UTF-16）

变长编码

例如UTF-8编码，是变长编码（对于每一个字符，编码长度不同，这就是变长编码）

变长编码应用场景

在特定场景下，只有四种字符：a，b，0，1。a出现的概率：0.8，b出现的概率：0.05，0出现的概率：0.1，1出现的概率：0.05

在这提到一个概念——平均编码长度：每种字符编码长度 * 每种字符出现的概率

$p_i$ ：字符出现的概率， $l_i$ ：字符编码长度
$\sum p_i\ *\ l_i$

假设，平均编码长度 = 1.16，估算传输100个字符，需要传输116个比特位

哈夫曼编码

首先，统计得到每一种字符的概率
将n个字符，建立成一棵哈夫曼树
每一个字符，都落在叶子节点上
按照左 0，右 1 的形式，将编码读取出来

假设当前统计后有a，b，0，1四种字符，a的概率：0.8，b的概率：0.05，0的概率：0.1，c的概率：0.05

需要将四个字符作为四个叶子节点连接到一棵树上，每次拿出概率最小的两个字符连成一棵子树

在这里插入图片描述

此时，概率最低的两个节点为b和1生成的新节点，以及字符0

在这里插入图片描述

最后，将a字符与0.2的节点合成一棵子树

在这里插入图片描述

可以发现，四个字符都在叶子节点的位置，因为所有字符都落在叶子节点上，所以我们没有任何一个字符是另一个字符的前缀

a：0，b：110，0：10，1：111，平均编码长度： $1 * 0.8 + 3 * 0.05 + 2 * 0.1 + 3 * 0.05 = 1.3$

结论：哈夫曼编码是最优的变长编码

C语言实现哈夫曼树

#include <stdio.h>
#include <stdlib.h>

#define swap(a, b) {\
    __typeof(a) __tmp = a;\
    a = b; b = __tmp;\
}

typedef struct Node {
    char ch;    //当前节点代表的字符
    double p;   //当前节点的概率值
    struct Node *lchild, *rchild;
} Node;

Node *getNewNode(char ch, double per) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->ch = ch;
    p->p = per;
    p->lchild = p->rchild = NULL;
    return p;
}

// 两个节点合并
Node *CombinNode(Node *a, Node *b) {
    Node *p = getNewNode(0, a->p + b->p);
    p->lchild = a;
    p->rchild = b;
    return p;
}


void pick_min(Node **arr, int n) {
    for (int j = n - 1; j >= 0; j --) {
        if (arr[n]->p > arr[j]->p) {
            swap(arr[n], arr[j]);
        }
    }
    return ;
}

// 获得一棵哈夫曼树（可以用堆优化）
Node *getHaffmanTree(Node **arr, int n) {
    // n个节点需要合并n - 1次
    for (int i = 1; i < n; i ++) {
        // 找出当前的概率最小的字符
        pick_min(arr, n - i);
        // 找出当前的概率次小的字符
        pick_min(arr, n - i - 1);
        // 将这两个节点合并
        arr[n - i - 1] = CombinNode(arr[n - i], arr[n - i - 1]);
    }
    return arr[0];
}

//
void __output_code(Node *root, char *str, int k) {
    str[k] = 0;
    // 如果是叶子节点,直接输出
    if (root->lchild == NULL && root->rchild == NULL) {
        printf("%c %s\n", root->ch, str);
        return ;
    }
    str[k] = '0';
    __output_code(root->lchild, str, k + 1);
    str[k] = '1';
    __output_code(root->rchild, str, k + 1);
    return ;
}

// 输出每个字符的哈夫曼编码
void output_code(Node *root) {
    char str[100];
    __output_code(root, str, 0);
    return ;
}

//销毁
void clear(Node *root) {
    if (!root) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

int main() {
    int n;
    scanf("%d", &n);
    Node **arr;
    arr = (Node **)malloc(sizeof(Node *) * n);
    for (int i = 0; i < n; i ++) {
        char ch[10];
        double p;
        scanf("%s%lf", ch, &p);
        arr[i] = getNewNode(ch[0], p);
    }
    Node *root = getHaffmanTree(arr, n);
    output_code(root);
    clear(root);
    free(arr);
    return 0;
}