实验三（必做，基本实验，4学时）实验题目：Huffman树及Huffman编码的算法实现

最新推荐文章于 2024-10-08 20:32:22 发布
最新推荐文章于 2024-10-08 20:32:22 发布
阅读量161 收藏
点赞数
文章标签： 算法 c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63171424/article/details/131704575
版权

实验目的：

1、 了解该树的应用实例，熟悉掌握Huffman树的构造方法及Huffman编码的应用，

2、 了解Huffman树在通信、编码领域的应用过程。

实验要求：

1、输入一段100—200字的英文短文，存入一文件a中。

2、写函数统计短文出现的字母个数n及每个字母的出现次数

3、写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffman编码。

4、用每个字母编码对原短文进行编码，码文存入文件b中。

5、用Haffman树对b中码文进行译码，结果存入文件c中，比较a,c是否一致，以检验编码、译码的正确性。

实验内容和实验步骤：

1.先编辑基本的存储单元struct twshu 用来存储节点；

2，在主函数中完成文件读写到数组中并且编码；编码中调用了quanzhi（）；来辅助；

3.在编写用来创建单链的twshu* creatnode(int q, char a, int type) //创建节点

与twshu* creatlink(int num, char word) {  //创建第一条链表，这个链表是后面创建二叉树的基础,并且赋予权值和对应的字母，按权值大小排序。

4.编写创建二叉树的编码 twshu* creatwshu(twshu* link, int quan[52], char A[52]) {  //创建二叉树，创建的思想为根据之前创建的有序link，最开始的两个最小，最小的两个形成新的节点并且接入到链表中

5.编写为每个字母编码的函数int bianma(twshu* head, char  hfm[52][52], char A[52], char b[1], int i, int j) {//对每一个叶子对应的字母进行编码，编码方式为进行一遍先根遍历，每遍历一次左子树加是对应的哈夫曼编码加0，每遍历一遍右子树加一，如果遍历的节点是叶子的话使标记hfm编码数组的值加一并返回，

6.以哈夫曼码为基础，编写char *bianmafile(char  hfm[52][52], char A[52], twshu* head, char str[N + 1]) {//根据哈夫曼码及其对应的字母对整个文件进行编码

7. 编写译码函数译码char* yima(char bstr[N * 52], twshu* head) {//根据编码文件，遍历译码树，当访问到叶子的时候返回相应的数值并且从头开始继续遍历

8.在主函数中依次进行权值计算，单链的创建，哈夫曼树的建立，为哈夫曼树编码，为文件编码，为文件译码这些过程，并且将文件存储到根目录下。

代码如下：

#include<stdio.h>

#include <string>

#include <math.h>

#define N 1000

struct twshu {

    int number;

    int type;//0是根，1是节点，2是叶子

    char elem;

    twshu* lchild, * rchild, * next = NULL;

};

void compare(twshu* link, int quan);

twshu* creatlink(int num, char word);

twshu* creatwshu(twshu* link, int quan[52], char A[52]);

int bianma(twshu* head, char hfm[52][52], char A[52], char b[1], int i, int j);

char* bianmafile(char hfm[52][52], char A[52], twshu* head, char str[N + 1]);

char yimashu(twshu* head, char bstr[N * 52], int& i);

char* yima(char bstr[N * 52], twshu* head);

int quanzhi(char str[N + 1], char elem) {//为每一个字母返回权值

    int quan = 0;

    int i = 0;

    while (str[i] != NULL)

    {

        if (elem == str[i]) quan++;

        i++;

    }

    return quan;

}

twshu* creatnode(int q, char a, int type) {   //创建节点

    twshu* node = ((twshu*)malloc(sizeof(twshu)));

    node->type = type;

    node->number = q;

    node->elem = a;

    node->rchild = NULL;

    node->lchild = NULL;

    node->next = NULL;

    return node;

}

void compare(twshu* link, int quan) {              //为运算一次之后的权值排序，截止条件是数值大于运算后的权值

    twshu* p = link;

    while (p != NULL && p->number <= quan) {

        twshu* q = p;

        while (q != NULL && q->number <= quan) {

            if (p->number > q->number) {

                twshu* lchild = p->lchild;

                int number = p->number;

                twshu* rchild = p->rchild;

                char elem = p->elem;

                int type = p->type;

                p->lchild = q->lchild;

                p->number = q->number;

                p->rchild = q->rchild;

                p->elem = q->elem;

                p->type = q->type;

                q->lchild = lchild;

                q->number = number;

                q->rchild = rchild;

                q->elem = elem;

                q->type = type;

            }

            q = q->next;

        }

        p = p->next;

    }

}

twshu* creatlink(int num, char word) {  //创建第一条链表，这个链表是后面创建二叉树的基础

    twshu* node = (twshu*)malloc(sizeof(twshu));

    node->lchild = NULL;

    node->number = num;

    node->rchild = NULL;

    node->type = 2;

    node->elem = word;

    node->next = NULL;

    return node;

}

twshu* creatwshu(twshu* link, int quan[52], char A[52]) {  //创建二叉树，创建的思想为根据之前创建的有序link，最开始的两个最小，最小的两个形成新的节点并且接入到链表中

    if (link->next != NULL)

    {

        twshu* temp = NULL;

        twshu* q = link->next;

        while (q->next != NULL) {

            temp = (twshu*)malloc(sizeof(twshu));

            temp->next = q->next->next;

            temp->lchild = q;

            temp->rchild = q->next;

            q = temp;

            q->number = quan[0] + quan[1];

            q->type = 1;

            q->elem = 0;

            compare(q, q->number);

        }

        return q;

    }

    else {

        return NULL;

    }

}

int bianma(twshu* head, char  hfm[52][52], char A[52], char b[1], int i, int j) {//对每一个叶子对应的字母进行编码，编码方式为进行一遍先根遍历，每遍历一次左子树加是对应的哈夫曼编码加0，每遍历一遍右子树加一，如果遍历的节点是叶子的话使标记hfm编码数组的值加一并返回，

    twshu* p = head;

    j++;

    if (b [0] != '2') {

        hfm[i][j] = b[0];

    }

    if (head->lchild == NULL && head->rchild == NULL)

    {

        A[i] = head->elem;

        int t = 0;

        for (int t = 0; t < j; t++)

        {

            if (i != 0 && hfm[i][t] == NULL)

            {

                hfm[i][t] = hfm[i - 1][t];

            }

        }

        i++;

        return i;

    }

    int t = j;

    char b0[1] = { '0' };

    char b1[1] = { '1' };

    i = bianma(head->lchild, hfm, A, b0, i, j);

    j = t;

    i = bianma(head->rchild, hfm, A, b1, i, j);

    return i;

}

char *bianmafile(char  hfm[52][52], char A[52], twshu* head, char str[N + 1]) {//根据哈夫曼码及其对应的字母对整个文件进行编码

    char bstr[52 * N]={};

    int i = 0, j = 0, t = 0, n = 0;

    while (str[i] != NULL) {

        t = 0;

        while (A[t] != str[i] && t < 52) { t++; }

        if (t < 52) {

                while (hfm[t][n] != NULL) {

                    bstr[j] = hfm[t][n];

                    n++;

                    j++;

                }

        }

        n = 0;

        i++;

    }

    return bstr;

}

char yimashu(twshu* head, char bstr[N * 52], int& i) {

    if (head->lchild == NULL && head->rchild == NULL) return head->elem;

    if (bstr[i] == '0') {

        i++;

        return yimashu(head->lchild, bstr, i);

    }

    else {

        i++;

        return yimashu(head->rchild, bstr, i);

    }

}

char* yima(char bstr[N * 52], twshu* head) {//根据编码文件，遍历译码树，当访问到叶子的时候返回相应的数值并且从头开始继续遍历

    char xstr[N+1]={};

    int i = 0, j = 0;

    while (bstr[i] != NULL) {

        xstr[j] = yimashu(head, bstr, i);

        j++;

    }

    return xstr;

}

int main()

{

    FILE* f;

    char str[N + 1] = {};

    char astr[N + 1] = {};

    char fstr[N + 1] = {};

    int quan[52], i = 0, sum = 0, j = 0;

    char hfm[52][52] = {};

    char A[52]={};

    int one = 1;

    char* bstr;

    char  cstr[52 * N]={};

    char* xstr;

    errno_t err = fopen_s(&f, "data.txt", "r");

    for (i = 0; i < 52; i++)

    {

        quan[i] = 0;

    }

    i = 0;

    if (f != NULL)

    {

        printf("fopen ok\n");

    }

    char c;

    while ((c = fgetc(f)) != EOF && i < 999) { // 逐个读取字符并存储到数组中

        fstr[i] = c;

        i++;

    }

    printf("文件中的原内容为\n");

    printf("%s\n", fstr);

    i = 0;

    while (fstr[i] != '/0'&&i<N) {//计算每个字母的权值

        one = 1;

        int j = 0;

        while (A[j] != NULL) {

            if (fstr[i] == A[j]) one = 0;

            j++;

        }

        if (one) {

            if ((fstr[i] >= 'a' && fstr[i] <= 'z') || (fstr[i] >= 'A' && fstr[i] < ='Z'))

            {

                A[sum] = fstr[i];

                quan[sum] = quanzhi(fstr, fstr[i]);

                sum++;

            }

        }

        i++;

    }

    sum = 0;

    for (i = 0; A[i] != NULL && quan[i] != NULL; i++) {//按权值大小排序

        for (int j = i + 1; A[j] != NULL && quan[j] != NULL; j++) {

            if (quan[i] > quan[j]) {

                int temp = quan[i];

                char TEMP = A[i];

                A[i] = A[j];

                quan[i] = quan[j];

                A[j] = TEMP;

                quan[j] = temp;

            }

        }

    }

    twshu* link = creatlink(0, 0);

    twshu* p = link;

    i = 0;

    while (A[i] != NULL) {   //将权值连成链表

        p->next = creatlink(quan[i], A[i]);

        p = p->next;

        i++;

    }

    twshu* head = creatwshu(link, quan, A);//返回哈夫曼树

    if (head != NULL) {

        head->elem = 0;

        head->type = 0;

    }

    else {

        printf("创建树失败");

    }

    char b[1] = { '2' };

    bianma(head, hfm, A, b, 0, -2);

    printf("bianma操作:输出每个字母对应的编码\n");//输出每个字母对应的编码

    i = 0;

    while (A[i] != NULL) {

        printf("%c=%s\n", A[i], hfm[i]);

        i++;

    }

    i = 0; j = 0;

    if (f != 0)

        fclose(f);

    bstr = bianmafile(hfm, A, head, fstr);

    err=fopen_s(&f,"databianma.txt", "w");

    if (f != NULL) {

        printf("\n写入bianma文件打开成功\n");

        fwrite(bstr, sizeof(char), sizeof(cstr), f);

        fclose(f);

    }

    err = fopen_s(&f,"databianma.txt", "r");

    i = 0;

    while ((c = fgetc(f)) != EOF && i < 5000) { // 逐个读取字符并存储到数组中

        cstr[i] = c;

        i++;

    }

    bstr = cstr;

    fclose(f);

    printf("\n\n编码结果：\n%s", bstr);

    i = 0;

    xstr = yima(bstr, head);

    int size = 0;

    while (xstr[size] != NULL)

    {

        astr[size] = xstr[size];

        size++;

    }

    err = fopen_s(&f,"datayima.txt", "w");

    printf("\n译码的结果：\n%s", astr);

    if (f != NULL) {

        printf("\n写入文件已经打开\n");

        fprintf(f, " % s", astr);

        fclose(f);

    }

    printf("\nendend\n");

    return 0;

}

青岛joker
关注
数据结构-哈夫曼编码实验
weixin_60925698的博客
03-29 831
哈夫曼编码实验
Huffman编码的c和matlab实现
03-16
#### 三、实验学时 本实验计划安排4个学时。 #### 四、实验内容 根据Huffman编码的基本原理，开发一个软件，该软件能对英文文本进行压缩和解压缩。软件功能应包括： 1. **字符频率统计**：统计文本中每个字符...
【数据结构与算法】超详细哈夫曼编码JAVA解释
weixin_45720193的博客
01-04 1873
依据文档要求，用户需要输入源文件和目标文件名，那么如何将提取源文件内容是重点，常见的提取方式是提取源文件的字符，即采用char数组存储，然而这种方式只能实现对文本文件的压缩和解压，不能对非文本文件进行压缩和解压，并且要实现任何文件的哈夫曼编码，只能对源文件中的字节进行哈夫曼编码，而采用int数组在实现转换字节的理解和编程上困难，故本文采用byte数组进行模拟，并且通过输入流提取源文件的字节数组。当递归到叶子节点时，将节点的字节值作为哈夫曼编码map的key，将对应的哈夫曼编码字符串作为map的value。
数据结构实验三：Huffman树及Huffman编码的算法实现
qq_22657279的博客
05-20 3761
Exp03 Huffman树及Huffman编码的算法实现 Author: Maskros 实验目的 了解该树的应用实例，熟悉掌握Huffman树的构造方法及Huffman编码的应用， 了解Huffman树在通信、编码领域的应用过程。Huffman树及Huffman编码的算法实现 实验内容与要求 输入一段100—200字的英文短文，存入一文件a中。 写函数统计短文出现的字母个数n及每个字母的出现次数 写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffm
【数据结构】Huffman树及Huffman编码的算法实现
Y0704__00的博客
10-31 637
Huffman树为最优二叉树，是一类带权路径长度最短的树。利用Huffman树求得的用于通信的二进制编码称为Huffman编码，创建编码的时间复杂度大致为O(nlogn)。Huffman编码可以之后的字符串的平均长度降低，从而可以达到无损压缩数据的目的。
Huffman树及Huffman编码，译码的算法实现
热门推荐
Wood_Du的博客
05-18 1万+
参考：https://blog.csdn.net/curson_/article/details/53771386 本来以为这个实验一会儿就可以搓出来，最后跟着要求搓了几个小时，菜是原罪，菜是真的菜，（助教小姐姐很好） 要求： 1、输入一段100—200字的英文短文，存入一文件a中。 2、写函数统计短文出现的字母个数n及每个字母的出现次数 3、写函数以字母出现次数作权值，建Haffman...
Huffman编码，文本压缩
蜂蜜柚子茶的博客
05-24 963
实验四、Huffman编码实现文本压缩 实验题目：Huffman树及Huffman编码的算法实现 实验目的： 1、 了解该树的应用实例，熟悉掌握Huffman树的构造方法及Huffman编码的应用。 2、 了解Huffman树在通信、编码领域的应用过程。 实验要求： 1、输入一段100—200字的英文短文，存入一文件a中。 2、写函数统计短文出现的字符个数n及每个字符的出现次数 3...
Huffman编码与译码数据结构设计性实验.pdf
07-14
在该实验中，学生被要求掌握Huffman编码与译码的基本概念，以及如何利用数据结构来设计相关的算法。实验的具体内容包括以下几个部分： 1. **字符频度分析**： 实验提供了26个英文字母的出现频度，例如，'e'出现103...
《信息论与编码》课程实验指导书
11-16
- **实验目的**：掌握Huffman编码的基本原理和实现方法。 - **实验学时**：2学时 - **实验准备**： - 理解Huffman编码的概念及其应用。 - 设计用于实现Huffman编码的数据结构和算法。 - **实验内容及步骤**： - ...
哈夫曼编码 贪心算法.pdf
10-30
哈夫曼编码是一种高效的前缀编码方法，常用于数据压缩。...实验时间预计为2学时，属于必做实验。通过完成这个实验，学生能够深入理解哈夫曼编码的工作原理，并具备实际应用贪心算法解决数据压缩问题的能力。
数据结构设计性实验
12-20
本实验旨在使学生掌握Huffman树的构建方法以及Huffman编码与译码的基本原理，并能够编写相应的程序实现这些功能。 #### 实验目标 1. **理论基础掌握**：理解Huffman树的概念、构建方法及其在编码中的应用。 2. **...
Huffman树及Huffman编码的算法实现
m0_57659214的博客
01-01 1183
Huffman树及Huffman编码的算法实现（必做，验证性实验） 实验目的 熟悉掌握Huffman树的构造方法及Huffman编码的应用，了解Huffman树在通信、编码领域的应用过程。 实验内容 （1）输入一段100—200字的英文短文，存入一文件a中。 （2）写函数统计短文出现的字母个数n及每个字母的出现次数 （3）写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffman编码。 （4）用每个字母编码对原短文进行编码，码文存入文件b中。 （5）用Haffman树对文件b
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 576
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 376
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 867
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
生成哈夫曼树
最新发布
TTz012的博客
10-08 130
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1242
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 813
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
C语言实现Huffman编码压缩与解压缩
“Huffman编码 C语言版”是一个关于使用C语言实现Huffman编码算法的实验项目，旨在让学生熟练掌握Huffman编码的原理及其在文件压缩和还原中的应用。实验详细讲解了Huffman编码的背景、重点与难点，并提供了4学时的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值