哈夫曼编码（小顶堆）

已于 2024-08-19 18:03:46 修改
阅读量495 收藏 3
点赞数 4
文章标签： 算法 c语言 数据结构 后端 开发语言
于 2024-08-19 18:00:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74143684/article/details/141305283
版权

一、什么是哈夫曼编码：

哈夫曼编码是一种根据字符出现频率设计的变长编码方式，常用于数据压缩。它的基本思想是，将出现频率较高的字符用较短的编码表示，而出现频率较低的字符用较长的编码表示，从而减小编码的总长度。

二、如何构建哈夫曼编码： 

        （1）普通构建哈夫曼编码：
  1. 统计字符的频率，根据字符出现的频率高低构建字符频率表；
  2. 将字符频率表中的每个字符创建成一个单独的树节点；
  3. 从字符频率表中选择两个频率最低的节点，合并为一个新的节点，其频率为两个节点的频率之和，将这个新节点插入到字符频率表中；
  4. 重复步骤3，直到字符频率表中只剩下一个节点，即哈夫曼树的根节点；
  5. 对哈夫曼树进行遍历，左子树标记为0，右子树标记为1，标记每个字符对应的编码；
  6. 使用编码替换原来的字符，得到哈夫曼编码。
        （2） 小顶堆构建哈夫曼编码：
  1. 统计字符的频率，根据字符出现频率的高低构建小顶堆；
  2. 将小顶堆中的每个字符创建成一个单独的树节点；
  3. 从小顶堆中依次弹出两个头节点（即两个频率最低的节点），合并为一个新的节点，其频率为两个节点的频率之和，将这个新节点重新插入到小顶堆中；
  4. 重复步骤3，直到小顶堆中只剩下一个节点，即哈夫曼树的根节点；
  5. 对哈夫曼树进行遍历，左子树标记为0，右子树标记为1，标记每个字符对应的编码；
  6. 使用编码替换原来的字符，得到哈夫曼编码。
           (3)小顶堆构建如图：

         （4）构建哈夫曼编树如图：

 左0右1，频率最低的两个节点相结合，频率相加作为一个新节点，以此类推。

 三、使用小顶堆来优化构建哈夫曼树的优点：

  (1)使用小顶堆来优化构建哈夫曼树，能够提高代码的运行效率，同时缩短了该算法的时间复杂度。

（2）对于实现哈夫曼树的代码可以得到优化，简化代码，大大提高代码的可读性。

（3）淘汰掉了繁琐的应寻表操作而存在的循环操作。

四、代码实现 ：

（1）创建一个结构体（作为树节点）：
typedef struct Node {
    char ch;  //字符，也可以是数字
    int freq; //字符出现的频率
    struct Node *lchild, *rchild; //左、右子树
} Node;
（2）创建一个结构体（作为小顶堆节点）：
typedef struct Heap { 
    Node **__data, **data; //__data,data分别为指针数组，__data指针数组偏移后的指针数组，类型为Node
    int n, size; //n表示数组中的元素个数，size表示数组的大小
} Heap;
（3）初始化树节点：
Node *getNewNode(int freq, char ch) {
    Node *p = (Node *)malloc(sizeof(Node)); //为指针p开辟空间，类型为Node
    p->ch = ch; //赋值
    p->freq = freq; //赋值
    p->lchild = p->rchild = NULL; //初始化左，右子树
    return p;
}
（4）初始化堆节点：
Heap *getNewHeap(int size) {
    Heap *h = (Heap *)malloc(sizeof(Heap)); //开辟指针h的存储空间，类型为Heap
    h->__data = (Node **)malloc(sizeof(Node *) * size); //开辟指针数据的存储空间
    h->data = h->__data - 1; //进行__data-1的偏移操作，使得data从1开始
    h->n = 0; //初始化n
    h->size = size; //赋值
    return h;
}
（5）向堆中插入元素：
#define swap(a, b) { \  //交换元素a,b
    __typeof(a) __c = (a); \  //将a的值赋给__c，__c的类型与a相同
    (a) = (b), (b) = __c; \  //将b的值赋给a，__c的值赋给b
}
int fullHeap(Heap *h) { //判断堆是否为满
    return h->n == h->size;
}
int cmpHeap(Heap *h, int i, int j) { //i为要判断的节点的下标，j为该节点的父节点
    return h->data[i]->freq < h->data[j]->freq; //小顶堆，子节点小于父节点，为真，要交换
}
void up_maintain(Heap *h, int i) { //向上调整
    while (i > 1 && cmpHeap(h, i, i / 2)) { //i>1为该树有子节点，cmpHeap比较子、父节点
        swap(h->data[i], h->data[i / 2]); //如果子节点小于父节点，交换
        i = i / 2; //从子节点向上调整到父节点（二叉树左（2*i),中(i),右(2*i+1)
    }
    return ;
}
int pushHeap(Heap *h, Node *n) { //插入数据
    if (fullHeap(h)) return 0; //判满
    h->n += 1; //每插入一个节点，n加一操作
    h->data[h->n] = n; //在指针数组中n的位置上插入节点n
    up_maintain(h, h->n); //向上调整
    return 1;
}
（6）从堆中弹出元素：
int emptyHeap(Heap *h) { //判空
    return h->n == 0;
}
Node *top(Heap *h) { //返回头节点
    if (emptyHeap(h)) return NULL; //判空
    return h->data[1]; //头节点
}
void down_maintain(Heap *h, int i) { //向下调整
    while (i * 2 <= h->n) { //向下调整的节点数不能超过数组中已有的节点数，i*2为左节点下标
        int ind = i, l = i * 2, r = i * 2 + 1; //ind为标记最小值，l为左节点下标，r为右节点下标
        if (cmpHeap(h, l, ind)) ind = l; //如果左节点的值小于父节点的值，标记l;
        if (r <= h->n && cmpHeap(h, r, ind)) ind = r; //如果如果右节点的值小于父节点的值，标记r;
        if (ind == i) return ; //如果上述条件都不满足，且满足此条件，则无需任何操作
        swap(h->data[i], h->data[ind]); //将下标为ind的节点与下标为i的节点交换
        i = ind; //从左或右子节点向下调整。
    }
    return ;
}
int popHeap(Heap *h) { //弹出元素
    if (emptyHeap(h)) return 0; //判空
    h->data[1] = h->data[h->n]; //将头节点弹出后，重新调整堆
    h->n -= 1; //弹出元素后，n-1操作
    down_maintain(h, 1);//向下调整，从头节点开始，将堆重新调整成小顶堆
    return 1;
}
（7）构建哈夫曼树：
 void clearHeap(Heap *h) { //释放空间
    if (h == NULL) return ;
    free(h->__data); //释放指针数组所占用的存储空间
    free(h); //释放指针所占用的存储空间
    return ;
}

int find_min_node(Node **node_arr, int n) { //寻找频率最小的节点的下标
    int ind = 0;
    for (int j = 1; j <= n; j++) {
        if (node_arr[ind]->freq > node_arr[j]->freq) ind = j; //标记为j
    }
    return ind;
}
 
Node *buildHaffmanTree(Node **node_arr, int n) { //构建哈夫曼树
    Heap *h = getNewHeap(n); //初始化小顶堆
    for (int i = 0; i < n; i++) pushHeap(h, node_arr[i]); //将所有节点压入堆中
    for (int i = 1; i < n; i++) {
        Node *node1 = top(h); //获取第一个头节点
        popHeap(h); //弹出操作
        Node *node2 = top(h); //获取第二个节点
        popHeap(h); //弹出操作
        Node *node3 = getNewNode(node1->freq + node2->freq, 0); //将两个节点的频率相加，作为新节点，字符初始化为0
        node3->lchild = node1; //新节点的左子树为第一个头节点
        node3->rchild = node2; //新节点的右节点为第二个头节点
        pushHeap(h, node3); //将新节点插入堆，继续寻找两个最小频率节点，再结合成新节点
    }
    Node *ret = top(h); //最后返回堆的头节点，即为哈夫曼树的头节点
    clearHeap(h);
    return ret;
}

（八）构建哈夫曼编码：

#define MAX_CHAR_NUM 128 //ASCII码
char *char_code[MAX_CHAR_NUM] = {0}; //初始化为0
 
void extractHaffmanCode(Node *root, char buff[], int k) { //第k个位置
    buff[k] = 0;//初始化
    if (root->lchild == NULL && root->rchild == NULL) { //如果该节点的左、右节点皆无，即叶子节点
        char_code[root->ch] = strdup(buff); //将buff复制给下标为root->ch(char变int)对应的字符
        return ;
    }
    buff[k] = '0'; //左零
    extractHaffmanCode(root->lchild, buff, k + 1); //递归左子树
    buff[k] = '1'; //右一
    extractHaffmanCode(root->rchild, buff, k + 1); //递归右子树
    return ;
}

五、完整代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define swap(a, b) { \
    __typeof(a) __c = a; \
    a = b, b = __c; \
}
typedef struct Node {
    char ch;
    int freq;
    struct Node *lchild, *rchild;
} Node;
typedef struct Heap {
    Node **__data, **data;
    int n, size;
} Heap;
Heap *getNewHeap(int size) {
    Heap *h = (Heap *)malloc(sizeof(Heap));
    h->__data = (Node **)malloc(sizeof(Node *) * size);
    h->data = h->__data - 1;
    h->n = 0;
    h->size = size;
    return h;
}
int fullHeap(Heap *h) {
    return h->n == h->size;
}
 
int emptyHeap(Heap *h) {
    return h->n == 0;
}
Node *top(Heap *h) {
    if (emptyHeap(h)) return NULL;
    return h->data[1];
}
int cmpHeap(Heap *h, int i, int j) {
    return h->data[i]->freq < h->data[j]->freq;
}
void up_maintain(Heap *h, int i) {
    while (i > 1 && cmpHeap(h, i, i / 2)) {
        swap(h->data[i], h->data[i / 2]);
        i = i / 2;
    }
    return ;
}
void down_maintain(Heap *h, int i) {
    while (i * 2 <= h->n) {
        int ind = i, l = i * 2, r = i * 2 + 1;
        if (cmpHeap(h, l, ind)) ind = l; 
        if (r <= h->n && cmpHeap(h, r, ind)) ind = r;
        if (ind == i) return ;
        swap(h->data[i], h->data[ind]);
        i = ind;
    }
    return ;
}
int pushHeap(Heap *h, Node *n) {
    if (fullHeap(h)) return 0;
    h->n += 1;
    h->data[h->n] = n;
    up_maintain(h, h->n);
    return 1;
}
int popHeap(Heap *h) {
    if (emptyHeap(h)) return 0;
    h->data[1] = h->data[h->n];
    h->n -= 1;
    down_maintain(h, 1);
    return 1;
}
void clearHeap(Heap *h) {
    if (h == NULL) return ;
    free(h->__data);
    free(h);
    return ;
}
Node *getNewNode(int freq, char ch) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->ch = ch;
    p->freq = freq;
    p->lchild = p->rchild = NULL;
    return p;
}
int find_min_node(Node **node_arr, int n) {
    int ind = 0;
    for (int j = 1; j <= n; j++) {
        if (node_arr[ind]->freq > node_arr[j]->freq) ind = j;
    }
    return ind;
}
Node *buildHaffmanTree(Node **node_arr, int n) {
    Heap *h = getNewHeap(n);
    for (int i = 0; i <n; i++) pushHeap(h, node_arr[i]);
    for (int i = 1; i < n; i++) {
        Node *node1 = top(h);
        popHeap(h);
        Node *node2 = top(h);
        popHeap(h);
        Node *node3 = getNewNode(node1->freq + node2->freq, 0);
        node3->lchild = node1;
        node3->rchild = node2;
        pushHeap(h, node3);
    }
    Node *ret = top(h);
    clearHeap(h);
    return ret;
}
void clear(Node *root) {
    if (root == NULL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}
 
#define MAX_CHAR_NUM 128
char *char_code[MAX_CHAR_NUM] = {0};
void extractHaffmanCode(Node *root, char buff[], int k) {
    buff[k] = 0;
    if (root->lchild == NULL && root->rchild == NULL) {
        char_code[root->ch] = strdup(buff);
        return ;
    }
    buff[k] = '0';
    extractHaffmanCode(root->lchild, buff, k + 1);
    buff[k] = '1';
    extractHaffmanCode(root->rchild, buff, k + 1);
    return ;
}
int main() {
    char s[10];
    int n, freq;
    scanf("%d", &n);
    Node **node_arr = (Node **)malloc(sizeof(Node *) * n);
    for (int i = 0; i < n; i++) {
        scanf("%s%d", s, &freq);
        node_arr[i] = getNewNode(freq, s[0]);
    }
    Node *root = buildHaffmanTree(node_arr, n);
    char buff[1000];
    extractHaffmanCode(root, buff, 0);
    for (int i = 0; i < MAX_CHAR_NUM; i++) {
        if (char_code[i] == NULL) continue; //26个字符按顺序输出
        printf("%c : %s\n", i, char_code[i]);
    }
    free(*char_code);
    clear(root);
    return 0;
}

六、运行效果图： 

 文章到此结束!

枫林城
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
0023算法笔记——【贪心算法】哈夫曼编码问题
liufeng_king的专栏
03-26 11万+
1、问题描述       哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。一个包含100,000个字符的文件，各字符出现频率不同，如下表所示。     有多种方式表示文件中的信息，若用0,1码表示字符的方法，即每个字符用唯一的一个0,1串表示。若采用定长编码表
哈夫曼编码Huffman
01-08
哈夫曼编码 信息论与编码 信息安全基础实习 适用
《数据结构》实验——哈夫曼编码
07-12
《数据结构》实验，（人民邮电出版社）哈夫曼编码部分
数据结构与算法——赫夫曼编码
最新发布
weixin_45942515的博客
07-26 379
（1）赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式。属于一种程序算法。赫夫曼编码是赫夫曼树在电信通讯中经典的应用之一。（2）赫夫曼编码被广泛地应用于数据文件压缩。其压缩率通常在20%~90%之间。（3）赫夫曼编码是可变字长编码（VLC）的一种。Huffman于1952年提出一种编码方式，称为最佳编码。
PTA哈夫曼编码 (30分)
yan936462437的博客
02-07 1万+
PTA哈夫曼编码 (30分) 给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 ‘a’、‘x’、‘u’、‘z’ 的出现频率对应为 4、2、1、1。我们可以设计编码 {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}，也可以用另一套 {‘...
【数据结构与算法】-哈夫曼树(Huffman Tree)与哈夫曼编码
热门推荐
闪耀大叔的博客
07-25 5万+
超详细讲解哈夫曼树(Huffman Tree)以及哈夫曼编码的构造原理、方法，并用代码实现。
哈夫曼编码
简约不简单
02-17 129
装载请注明涞源chengyaogen.blog.chinaunix.net   前面一节我们知道了，怎样去创建一个哈夫曼树，这一节我们来看看哈夫曼编码。   思想：得到哈夫曼树后，自顶向下按路径编号，指向左节点的边编号0，指向右节点的边编号1，从根到叶节点的所有边上的0和1连接起来，就是叶子节点中字符的哈夫曼编码。   下图体现了哈夫曼编码的过程：     #in...
构建哈夫曼树(可构造哈夫曼编码)
10-29
给定n个权值作为n的叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。使用数组构建哈夫曼树，并可用该树构造哈夫曼编码。
哈夫曼树编码
02-25
1. **初始化**：将所有字符作为单个节点的树加入到优先级队列（通常是小顶堆）中，每个节点包含字符及其出现频率。 2. **合并节点**：从队列中取出权值最小的两棵树合并成一棵新的二叉树，新树的根节点权值为其两个...
哈夫曼编码器 ，内部排序，源码+文档
11-08
哈夫曼编码是一种高效的数据压缩方法，主要用于无损数据压缩，它通过构建最优的二叉树（也称为哈夫曼树）来为每个输入符号分配唯一的前缀编码。这种编码方式使得频繁出现的字符拥有较短的编码，不常出现的字符则编码...
实现哈夫曼树及哈夫曼编码（C语言版，利用小顶堆） 超详细！
qq_42890853的博客
08-15 803
#include<stdio.h> #include<stdlib.h> #define bug printf("***************************\n") #define maxn 100000 + 7 //定义哈夫曼树的结点 typedef struct LinkNode { int data; struct LinkNode* lchild; struct LinkNode* rchild; }LinkNode; int len; int st_p
7-1 哈夫曼编码 (30分)
流楚丶格念的博客
12-16 8754
文章目录7-1 哈夫曼编码 (30分)输入格式：输出格式：输入样例：输出样例：题解代码 7-1 哈夫曼编码 (30分) 给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 ‘a’、‘x’、‘u’、‘z’ 的出现频率对应为 4、2、1、1。我们可以设计编码 {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}，也可以用另一套 {‘a’=1, ‘x’=0
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值