哈夫曼编码C语言实现（数据结构，算法设计与分析贪心算法）

于 2024-05-18 17:23:33 发布
阅读量593 收藏 13
点赞数 13
文章标签： 数据结构 贪心算法 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80319862/article/details/139028184
版权

问题： 

输入：字符集C，每个字符出现的频率f

输出：每个字符的哈夫曼编码

思路：

采用贪心法，贪心策略是按字符出现频率由小到大排序存到优先队列中，正确性证明略。

用到的数据结构有链式队列，二叉树。

代码：

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

// 定义哈夫曼树的节点结构
typedef struct Node {
    char data;
    int freq;
    char* code;//哈夫曼编码数组 
    struct Node* left;
    struct Node* right;
} Node;

// 定义优先队列的节点结构
typedef struct QueueNode {
    Node* data;//指向哈夫曼树的节点的指针 
    struct QueueNode* next;
} QueueNode;

// 初始化一个空的优先队列
QueueNode* initQueue() {
    return NULL;
}

// 向优先队列中插入一个节点
QueueNode* insertQueue(QueueNode* head, Node* node) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = node;
    newNode->next = NULL;

    if (head == NULL || node->freq < head->data->freq) {
        newNode->next = head;
        return newNode;//如果当前节点频率最小作为新的头节点并返回新的头节点 
    }

    QueueNode* current = head;
    while (current->next != NULL && current->next->data->freq < node->freq) {
        current = current->next;
    }

    newNode->next = current->next;
    current->next = newNode;

    return head;//否则返回旧的 
}

// 从优先队列中取出频率最小的节点
Node* popQueue(QueueNode** head) {//指向头节点的指针的指针 
    if (*head == NULL) {
        return NULL;
    }

    Node* node = (*head)->data;
    QueueNode* temp = *head;
    *head = (*head)->next;
    free(temp);

    return node;
}

// 构建哈夫曼树
Node* buildHuffmanTree(char* C, int* f, int n) {
    QueueNode* queue = initQueue();

    for (int i = 0; i < n; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = C[i];
        node->freq = f[i];
        node->code = NULL;
        node->left = NULL;
        node->right = NULL;

        queue = insertQueue(queue, node);//把哈夫曼树节点放到优先队列中存储 
    }

    while (queue->next != NULL) {
        Node* left = popQueue(&queue);
        Node* right = popQueue(&queue);

        Node* parent = (Node*)malloc(sizeof(Node));
        parent->data = '\0';
        parent->freq = left->freq + right->freq;
        parent->code = NULL;
        parent->left = left;
        parent->right = right;

        queue = insertQueue(queue, parent);
    }

    return popQueue(&queue);//返回从优先队列中弹出的节点
}

// 递归遍历哈夫曼树，生成每个字符的哈夫曼编码
void generateHuffmanCode(Node* root, char* code, int index) {
    if (root == NULL) {
        return;
    }

    if (root->left == NULL && root->right == NULL) {
        code[index] = '\0';
        root->code = strdup(code);
        printf("Character %c: %s\n", root->data, root->code);
        return;
    }

    if (root->left != NULL) {
        code[index] = '0';
        generateHuffmanCode(root->left, code, index + 1);
    }

    if (root->right != NULL) {
        code[index] = '1';
        generateHuffmanCode(root->right, code, index + 1);
    }
}

// 主函数
int main() {
    char C[] = {'a', 'b', 'c', 'd', 'e'};
    int f[] = {5, 9, 12, 13, 16};
    int n = sizeof(C) / sizeof(C[0]);

    Node* root = buildHuffmanTree(C, f, n);

    char code[100];
    generateHuffmanCode(root, code, 0);

    return 0;
}

运行结果： 

 

难点解释： 

1.insertQueue函数 

QueueNode* insertQueue(QueueNode* head, Node* node) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = node;
    newNode->next = NULL;

    if (head == NULL || node->freq < head->data->freq) {
        newNode->next = head;
        return newNode;
    }

    QueueNode* current = head;
    while (current->next != NULL && current->next->data->freq < node->freq) {
        current = current->next;
    }

    newNode->next = current->next;
    current->next = newNode;

    return head;
}

 

这段代码是用来向优先队列中插入一个节点的函数 insertQueue。

  1. 首先，创建一个新的 QueueNode 结点 newNode，并为其分配内存空间。
  2. 将 node 赋值给 newNode 的 data，并将 newNode 的 next 指针设置为 NULL。
  3. 检查优先队列是否为空，或者新节点的频率是否小于优先队列中第一个节点的频率。如果是，则将新节点插入到队列的开头，并返回新的队列头节点。
  4. 如果不是上述情况，通过一个循环找到合适的位置将新节点插入到队列中，保持队列按照频率从小到大排序。
  5. 最后，将新节点插入到找到的位置，并返回队列的头节点。

这段代码的作用是确保优先队列中的节点按照频率从小到大排序，以便后续构建哈夫曼树时能够选择频率最小的节点。

2. buildHuffmanTree函数

Node* buildHuffmanTree(char* C, int* f, int n) {
    QueueNode* queue = initQueue();

    for (int i = 0; i < n; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = C[i];
        node->freq = f[i];
        node->code = NULL;
        node->left = NULL;
        node->right = NULL;

        queue = insertQueue(queue, node);//把哈夫曼树节点放到优先队列中存储 
    }

    while (queue->next != NULL) {
        Node* left = popQueue(&queue);
        Node* right = popQueue(&queue);

        Node* parent = (Node*)malloc(sizeof(Node));
        parent->data = '\0';
        parent->freq = left->freq + right->freq;
        parent->code = NULL;
        parent->left = left;
        parent->right = right;

        queue = insertQueue(queue, parent);
    }

    return popQueue(&queue);//返回从优先队列中弹出的节点
}

 在这段代码中，return popQueue(&queue); 的作用是返回从优先队列中弹出的节点，而不是返回整个队列。这是因为在哈夫曼树的构建过程中，我们通常需要从优先队列中弹出频率最小的节点，然后将其用于构建哈夫曼树。

3.generateHuffmanCode函数

void generateHuffmanCode(Node* root, char* code, int index) {
    if (root == NULL) {
        return;
    }

    if (root->left == NULL && root->right == NULL) {
        code[index] = '\0';
        root->code = strdup(code);
        printf("Character %c: %s\n", root->data, root->code);
        return;
    }

    if (root->left != NULL) {
        code[index] = '0';
        generateHuffmanCode(root->left, code, index + 1);
    }

    if (root->right != NULL) {
        code[index] = '1';
        generateHuffmanCode(root->right, code, index + 1);
    }
}

这段代码是用来生成哈夫曼编码的函数 generateHuffmanCode。

  1. 首先，检查传入的 root 结点是否为空，如果为空则直接返回，表示已经到达树的底部。
  2. 接着，检查当前结点是否为叶子结点（即没有左右子结点），如果是，则将当前路径上的编码保存到该叶子结点的 code 字段中，并打印出该叶子结点对应的字符和编码。
  3. 如果当前结点不是叶子结点，分别处理左子树和右子树：
    • 对于左子树，将当前路径上的编码设置为 '0'，然后递归调用 generateHuffmanCode 函数处理左子结点。
    • 对于右子树，将当前路径上的编码设置为 '1'，然后递归调用 generateHuffmanCode 函数处理右子结点。

通过不断递归向下处理左右子树，并在叶子结点处保存编码，最终可以生成哈夫曼树中每个字符对应的哈夫曼编码。这个过程是基于哈夫曼树的特点：左子树路径标记为 '0'，右子树路径标记为 '1'，从根结点到叶子结点的路径即为该字符的哈夫曼编码。

在整个过程中，index 参数用来记录当前路径上的位置，code 数组用来保存当前路径上的编码。最终生成的哈夫曼编码保存在每个叶子结点的 code 字段中。

2301_80319862
关注
  • 13
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
哈夫曼编码（贪心算法）.cpp
11-18
哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。资源为哈夫曼编码可执行文件
哈夫曼编码（贪心算法）报告.doc
12-26
《哈夫曼编码（贪心算法）报告》 哈夫曼编码是一种基于贪心策略的高效数据文件压缩编码方法，其核心在于通过构建最优前缀码来实现编码效率的最大化。在本实验报告中，我们将深入理解哈夫曼编码的工作原理、设计思想...
实现哈夫曼编码（C语言）
m0_57443189的博客
11-08 8158
编译环境：Dev-C++ 实现哈夫曼编码的贪心算法实现，并分析哈夫曼编码的算法复杂度。
贪心算法之哈夫曼编码（C语言实现）
W_ILU的博客
03-19 1万+
如题问题描述:现有一个文本文件，其中包含的字符数据出现的次数各不相同，先要求对该文本中包含的字符进行编码，使文本占用的位数更小。问题分析：我们知道文件的存储都是以二进制数表示的，如：字符c可以表示为010101…之类的。因为不同的操作系统对于不同的数据类型会分配给相同的数据容器长度，如C中int型数据固定占用4个字节的存储空间。现在问题时因为各个字符出现的概率不同，那么我们就可以给出现概率高的字符分
哈夫曼编码与解码（贪心算法） C++实现
liu798675179的专栏
11-19 8163
哈夫曼编码与解码（贪心算法） C++实现原理将原有的定长编码改为变长编码，字母次数出现多的使用小位数编码，字母次数出现少的使用多位数编码，总编码长度为： B(T)=∑c∈Cc.freq×dT(c)B(T)=\sum_{c\in C}c.freq\times d_{T}(c) 个二进制位。其中c.freqc.freq表示cc在文本中出现的频率，dT(c) d_{T}(c)表示字符cc的码字的长
【数据结构】树（七）—— 哈夫曼树（C语言版）
haoweixl的博客
07-04 8251
【数据结构】树（七）—— 哈夫曼树（C语言版）前言哈夫曼树的定义哈夫曼树的应用——哈夫曼编码 前言 哈夫曼树的定义 哈夫曼树的应用——哈夫曼编码
c语言哈夫曼编码 贪心,[C++]哈夫曼树(最优满二叉树) / 哈夫曼编码(贪心算法)
weixin_39891317的博客
05-18 1322
一 哈夫曼树1.1 基本概念算法思想贪心算法(以局部最优，谋求全局最优)适用范围1 【(约束)可行】：它必须满足问题的约束2 【局部最优】它是当前步骤中所有可行选择中最佳的局部选择3 【不可取消】选择一旦做出，在算法的后面步骤中，就无法再改变。示例【树论：最优(二叉)数=带权路径最短的树】【图论：单源最短路径=从某一结点出发至其他结点的带权路径之和最小 / 多源最短路径=某一对结点之间的带权路径之...
用贪心算法解哈夫曼编码问题(计算机算法设计与分析)
05-16
哈夫曼编码的构建过程可以用贪心算法来实现。以下是详细步骤： 1. **建立数学模型**：首先，我们需要一个字符集及其对应的出现频率。每个字符对应一个权值，权值表示该字符在文本中出现的次数。我们的目标是构建一...
数据结构 哈夫曼编码译码 C语言实现 项目及其报告
06-18
- 在这个项目中，数据结构主要体现在哈夫曼树和优先队列的构建与操作上，它们是哈夫曼编码算法的核心。 - `Huffman.cpp`可能包含了上述功能的实现代码，`datastructurereport.docx`可能是项目报告，详述了实现过程...
c语言实现哈夫曼编码
01-01
总结来说，C语言实现哈夫曼编码需要理解其基本原理，设计合适的数据结构，编写构建和遍历哈夫曼树的算法，以及生成和存储编码表。同时，计算平均码长能帮助评估编码效率。提供的"哈夫曼编码.docx"可能是关于这一主题...
哈夫曼编码的 C 语言实现
08-14
哈夫曼编码是一种无损的高效的压缩方法。对文本文件进行哈夫曼编码，使用计算信源熵打开一个文件进行概率计算，然后将输出的 submit.txt 文件用哈夫曼编码打开，之后就会对文本文件中出现的字符进行哈夫曼编码。
C语言用三种策略实现贪心算法
05-26
贪心算法： 是指在对问题进行求解时,在每一步选择中都采取最好或者最优(即最有利)的选择,从而希望能够导致结果是最好或者最优的算法。但贪心算法并不能保证得到全局最优。本实验选择【-1背包问题】，请用贪心算法求解(贪心策略的选择是关键)。 问题如下：有一个背包，背包容量是150kg。现有8个物品，物品大小固定，即不可分割。 要求：尽可能让装入背包中的物品总价值最大，但前提条件是：不能超过总容量150kg。 8件物品的标号、重量、价值如下表所示： 物品 重量 价值 1 35kg 10 2 30kg 40 3 6kg 30 4 50kg 50 5 40kg 35 6 10kg 40 7 25kg 30 8 12kg 25 代码采用了三种策略来实现
数据结构赫夫曼编码C语言
12-04
赫夫曼编码，数据结构实验代码
C语言做哈夫曼编码
06-19
用C语言做的数据结构中的哈夫曼树（英文字母有规律的与数字的转换）
计算机算法分析与设计（12）---贪心算法(最优装载问题和哈夫曼编码问题)
m0_62881487的博客
10-18 1250
1. 哈夫曼编码是在电讯通信中的应用之一，广泛地用于数据文件压缩的十分有效的编码方法，其压缩率通常在20%～90%之间。在电讯通信业务中，通常用二进制编码来表示字母或其他字符，并用这样的编码来表示字符序列。2. 例如：如果需传送的电文为ABACCDA‘ABACCDA’ABACCDA，它只用到四种字符，用两位二进制编码便可分辨。假设ABCDA, B, C, DABCD的编码分别为0001101100011011，则上述电文便为。
数据结构C语言实现哈夫曼编码、译码
m0_48445706的博客
08-29 4596
简单实现哈夫曼编码译码过程，简单易懂` #include<stdio.h> #include<string.h> #include<stdlib.h> #include<conio.h> typedef struct{ char ch; //字符 int weight; //权值 int parent,lchild,rchild; //双亲、左孩子、右孩子的下标 }HTNode,*HuffmanTree; typedef char **Huf
C语言实现数据结构——哈夫曼编码
热门推荐
qq_45746876的博客
11-22 1万+
哈夫曼编码前言哈夫曼树与哈夫曼编码介绍思路哈夫曼树的建立对外部结点进行哈夫曼编码代码实现勉强算是总结 前言 又快一周没有更新了，最近事情比较多，回家几天拖欠了一些作业和实验，所以最近小杨在疯狂的补作业和实验，所以就没有更新新文章，希望大家理解哈~ 有没有细心的小伙伴发现本人改了昵称又换了头像呢，没有的话就让本人来带大家稍微了解一下叭： 之前在刷最右的时候偶然看到了一个关于 山野下 的帖子，看完之后又去仔细的了解了一下，真的很有感触，现在我也是小榆的眼睛啦，想带她看看有关计算机的知识，希望她不会觉得枯燥呀。
哈夫曼编码解码C语言实现---数据结构
weixin_63186561的博客
08-05 2511
代码】哈夫曼编码解码C语言实现---数据结构。
哈夫曼编码 贪心算法 c语言实现
最新发布
10-28
哈夫曼编码是一种广泛用于数据文件压缩的编码方法，其压缩率通常在20%～90%之间。它利用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。哈夫曼编码实质上是利用最优二叉树原理，求最优前缀码的长度，即平均码长或文件总长最小的前缀编码。哈夫曼编码的实现过程可以使用贪心算法，即每次选择频率最小的两个字符进行合并，直到所有字符都被合并为止。C语言实现哈夫曼编码可以使用结构体来表示哈夫曼树节点，使用指针来实现树的构建和遍历，具体实现可以参考相关的C语言教材或者网上的代码示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值