哈夫曼编码

最新推荐文章于 2024-06-25 18:31:27 发布
最新推荐文章于 2024-06-25 18:31:27 发布
阅读量442 收藏 6
点赞数
原文链接：http://www.cnblogs.com/HyattXia/p/10049502.html
版权

编程实现：要传输一些数据（比如英文单词），设计一个利用哈夫曼算法的编码系统，为这些单词编码，并在接收端进行译码。基本要求:

（1）将需要传输的数据存放在数据文件data.txt 中。

（2）读入数据文件并为其编码，将编码后的内容存入文件code.txt中。

（3）读入code.txt，译码。并将译码后的内容输出在屏幕上。

 

事先准备好date.txt文件

PS:之前代码创建哈夫曼编码时有点个错误，改正了

代码如下：

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

//N为汉夫曼树叶子节点数 
#define N 256
//M为哈夫曼树所含节点总数 
#define M 2 * N - 1
//定义极大值 
#define INFINITE 0x3f3f3f3f
//date文件中的所含字符种类，本程序可以包括整个ASCII码 
#define CHAR_KINDS 256 

typedef struct{
    int weight;
    int parent;
    int LChild;
    int RChild;
    //用来存储汉夫曼树叶子节点的所存的信息，方便解码 
    int info; 
}HTNode, HuffmanTree[M + 1];

//哈夫曼编码 
typedef char *HuffmanCode[N + 1];

//选出两个权值最小的子树 
void Select(HuffmanTree *ht, int m, int *s1, int *s2){
    int minWeight = INFINITE;
    int i;
    for(i = 1; i <= m; i++){
        if((*ht)[i].weight < minWeight && (*ht)[i].parent == 0){
            minWeight = (*ht)[i].weight;
            *s1 = i;
        }
    }
    
    minWeight = INFINITE;
    for(i = 1; i <= m ;i++){
        if((*ht)[i].weight < minWeight && (*ht)[i].parent == 0 && i != *s1){
            minWeight = (*ht)[i].weight;
            *s2 = i;
        }
    }
}

//创建汉夫曼树 
void CrtHuffman(HuffmanTree *ht, int w[], int tw[], int n){
    int i, j = 0;
    //寻找非零的权值，并且对哈夫曼树叶子节点（子树）进行初始化 
    for(i = 1; i <= n; i++){
        (*ht)[i].weight = w[tw[i - 1]];
        (*ht)[i].parent = 0;
        (*ht)[i].LChild = 0;
        (*ht)[i].RChild = 0;
        (*ht)[i].info = tw[i - 1];
    }
     
    int m = n * 2 - 1;
    //对非叶子节点进行初始化 
    for(i = n  + 1; i <= m; i++){
        (*ht)[i].weight = 0;
        (*ht)[i].parent = 0;
        (*ht)[i].LChild = 0;
        (*ht)[i].RChild = 0;
        (*ht)[i].info = -1;
    }
    
    //构造哈夫曼树 
    for(i = n  + 1; i <= m; i++){
        int s1, s2;
        //选择连个权值最小的子树，创建新子树 
        Select(ht, i - 1, &s1, &s2);
        //新子树的权值等于选出来两个权值之和 
        (*ht)[i].weight = (*ht)[s1].weight + (*ht)[s2].weight;
        //s1子树和s2子树的双亲变成i 
        (*ht)[s1].parent = i;
        (*ht)[s2].parent = i;
        //i子树的左右孩子分别为s1和s2 
        (*ht)[i].LChild = s1;
        (*ht)[i].RChild = s2;
    }
}

//创建哈夫曼编码 
void CrtHuffmanCode(HuffmanTree *ht, HuffmanCode *hc, int w[], int tw[], int n){
    
    char *cd;
    cd = (char *)malloc(n * sizeof(char)));
    cd[n - 1] = '\0';
    
    int i, start, c, p;
    //对哈夫曼树的每个叶子节点进行编码 
    for(i = 1; i <= n; i++){
        
        start = n - 1;
        c = i;
        p = (*ht)[i].parent;
        
        //每个叶子节点的编码都是从叶子节点往树根推，直到此节点双亲为0，即到达根节点 
        while(p != 0){
            --start;
            //若为左分支，编码为0；右分支编码为1 
            if((*ht)[p].LChild == c) cd[start] = '0';
            else cd[start] = '1';
            c = p;
            p = (*ht)[p].parent;
        }
        
        (*hc)[tw[i - 1]] = (char *)malloc((n - start) * sizeof(char));
        
        strcpy((*hc)[tw[i - 1]], &cd[start]);
    }
    free(cd);
}

//统计权值 
void CountCharWeight(FILE **fp, int w[]){
    if((*fp = fopen("date.txt", "r+")) == NULL){
        printf("不能打开该文件\n");
        exit(0);
    }
    char ch;
    while(!feof(*fp)){
        ch = fgetc(*fp);
        if(ch == -1) break;
        w[(int)ch]++;
    }
}

//为每个字符进行编码，并且输出到date.txt文件中 
void Coding(FILE **sfp, FILE **cdfp, HuffmanCode *hc){
    if((*cdfp = fopen("code.txt", "w+")) == NULL){
        printf("不能打开该文件\n");
        exit(0);
    }
    //将源文本文件的文件标记指向文件开头 
    rewind(*sfp);
    
    char ch;
    while(!feof(*sfp)){
        ch = fgetc(*sfp);
        //由于feof(*sfp)函数只能判断当前位置是不是文件结束位置，编码会多一个
        //ch = fgetc(*sfp)会多往后走一个，则人为判断一下即可，即feof(*sfp)返回值为-1 
        if(ch == -1) break;
        fputs((*hc)[(int)ch], *cdfp);
    }
    fclose(*sfp);
}

//查找哈夫曼树的根 
int FindRoot(HuffmanTree *ht, int n){
    int i;
    int m = 2 * n - 1;
    for(i = 1; i <= m; i++){
        if((*ht)[i].weight != 0 && (*ht)[i].parent == 0 && (*ht)[i].LChild != 0 && (*ht)[i].RChild != 0){
            return i;
        }
    }
    return 0;
}

//解码 
void Decoding(HuffmanTree *ht, FILE **cdfp, int w[], int n){
    rewind(*cdfp);
    char ch;
    int root, son;
    //如果找到根便解码 
    if(root = FindRoot(ht, n)){
        son = root;
        //利用哈夫曼树进行解码 
        while(!feof(*cdfp)){
            ch = fgetc(*cdfp);
            if(ch == -1) break;
            if(ch == '0') son = (*ht)[son].LChild;
            else son = (*ht)[son].RChild;
            //如果到达叶子节点，便找到哈夫曼编码对应的信息，接着继续从根节点进行解码 
            if((*ht)[son].LChild == 0 && (*ht)[son].RChild == 0){
                printf("%c", (char)(*ht)[son].info);
                son = root;
            }
        }
    }
    fclose(*cdfp);
}

//统计不为零权值的个数，并且记录其下标到tw[] 
int GetWeightId(int tw[], int w[]){
    int i, n = 0;
    for(i = 0; i < CHAR_KINDS; i++){
        if(w[i] > 0){
            tw[n++] = i;
        }
    }
    return n;
}

int main(){
    FILE *fp1;
    int n = 0, i;
    //w[CHAR_KINDS]用来统计每个字符出现的次数
    //因为ASCII码右256个数量较大，有的字符不出现，权值为0
    //则weightId[CHAR_KINDS]用来存储权值不为0的ASCII码 
    int weightId[CHAR_KINDS], w[CHAR_KINDS];
    memset(w, 0, sizeof(w));
    for(i = 0; i < CHAR_KINDS; i++){
        weightId[i] = -1;
    }
    
    CountCharWeight(&fp1, w);
    
    HuffmanTree huffmantree;
    
    n = GetWeightId(weightId, w);

    HuffmanCode hc;
    CrtHuffman(&huffmantree, w, weightId, n);
    
    CrtHuffmanCode(&huffmantree, &hc, w, weightId, n);
    
    FILE *codefp;
    Coding(&fp1, &codefp, &hc);
    
    Decoding(&huffmantree, &codefp, w, n);
    printf("\n");
    return 0;
    
}

 

运行结果：

 

 

改进，把从文件读取字符换成int型变量，便可以对汉字和日文进行编码解码：

代码如下：

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

//N为汉夫曼树叶子节点数
#define N 256
//M为哈夫曼树所含节点总数
#define M 2 * N - 1
//定义极大值
#define INFINITE 0x3f3f3f3f
//date文件中的所含字符种类，本程序可以包括整个ASCII码
#define CHAR_KINDS 256

typedef struct{
    int weight;
    int parent;
    int LChild;
    int RChild;
    //用来存储汉夫曼树叶子节点的所存的信息，方便解码
    int info;
}HTNode, HuffmanTree[M + 1];

//哈夫曼编码
typedef char *HuffmanCode[N + 1];

//选出两个权值最小的子树
void Select(HuffmanTree *ht, int m, int *s1, int *s2){
    int minWeight = INFINITE;
    int i;
    for(i = 1; i <= m; i++){
        if((*ht)[i].weight < minWeight && (*ht)[i].parent == 0){
            minWeight = (*ht)[i].weight;
            *s1 = i;
        }
    }

    minWeight = INFINITE;
    for(i = 1; i <= m ;i++){
        if((*ht)[i].weight < minWeight && (*ht)[i].parent == 0 && i != *s1){
            minWeight = (*ht)[i].weight;
            *s2 = i;
        }
    }
}

//创建汉夫曼树
void CrtHuffman(HuffmanTree *ht, int w[], int tw[], int n){
    int i, j = 0;
    //寻找非零的权值，并且对哈夫曼树叶子节点（子树）进行初始化
    for(i = 1; i <= n; i++){
        (*ht)[i].weight = w[tw[i - 1]];
        (*ht)[i].parent = 0;
        (*ht)[i].LChild = 0;
        (*ht)[i].RChild = 0;
        (*ht)[i].info = tw[i - 1];
    }

    int m = n * 2 - 1;
    //对非叶子节点进行初始化
    for(i = n  + 1; i <= m; i++){
        (*ht)[i].weight = 0;
        (*ht)[i].parent = 0;
        (*ht)[i].LChild = 0;
        (*ht)[i].RChild = 0;
        (*ht)[i].info = -1;
    }

    //构造哈夫曼树
    for(i = n  + 1; i <= m; i++){
        int s1, s2;
        //选择连个权值最小的子树，创建新子树
        Select(ht, i - 1, &s1, &s2);
        //新子树的权值等于选出来两个权值之和
        (*ht)[i].weight = (*ht)[s1].weight + (*ht)[s2].weight;
        //s1子树和s2子树的双亲变成i
        (*ht)[s1].parent = i;
        (*ht)[s2].parent = i;
        //i子树的左右孩子分别为s1和s2
        (*ht)[i].LChild = s1;
        (*ht)[i].RChild = s2;
    }
}

//创建哈夫曼编码
void CrtHuffmanCode(HuffmanTree *ht, HuffmanCode *hc, int w[], int tw[], int n){

    char *cd;
    cd = (char *)malloc(n * sizeof(char));
    cd[n - 1] = '\0';

    int i, start, c, p;
    //对哈夫曼树的每个叶子节点进行编码
    for(i = 1; i <= n; i++){

        start = n - 1;
        c = i;
        p = (*ht)[i].parent;

        //每个叶子节点的编码都是从叶子节点往树根推，直到此节点双亲为0，即到达根节点
        while(p != 0){
            --start;
            //若为左分支，编码为0；右分支编码为1
            if((*ht)[p].LChild == c) cd[start] = '0';
            else cd[start] = '1';
            c = p;
            p = (*ht)[p].parent;
        }

        (*hc)[tw[i - 1]] = (char *)malloc((n - start) * sizeof(char));

        strcpy((*hc)[tw[i - 1]], &cd[start]);
    }
    free(cd);
}

//统计权值
void CountCharWeight(FILE **fp, int w[]){
    if((*fp = fopen("data.txt", "r+")) == NULL){
        printf("不能打开该文件\n");
        exit(0);
    }
    int ch;
    while(!feof(*fp)){
        ch = fgetc(*fp);
        if(ch == -1) break;
        w[ch]++;
    }
}

//为每个字符进行编码，并且输出到date.txt文件中
void Coding(FILE **sfp, FILE **cdfp, HuffmanCode *hc){
    if((*cdfp = fopen("code.txt", "w+")) == NULL){
        printf("不能打开该文件\n");
        exit(0);
    }
    //将源文本文件的文件标记指向文件开头
    rewind(*sfp);

    int ch;
    while(!feof(*sfp)){
        ch = fgetc(*sfp);
        //由于feof(*sfp)函数只能判断当前位置是不是文件结束位置，编码会多一个
        // = fgetc(*sfp)会多往后走一个，则人为判断一下即可，即feof(*sfp)返回值为-1
        if(ch == -1) break;
        fputs((*hc)[(int)ch], *cdfp);
    }
    fclose(*sfp);
}

//查找哈夫曼树的根
int FindRoot(HuffmanTree *ht, int n){
    int i;
    int m = 2 * n - 1;
    for(i = 1; i <= m; i++){
        if((*ht)[i].weight != 0 && (*ht)[i].parent == 0 && (*ht)[i].LChild != 0 && (*ht)[i].RChild != 0){
            return i;
        }
    }
    return 0;
}

//解码
void Decoding(HuffmanTree *ht, FILE **cdfp, int w[], int n){
    rewind(*cdfp);
    char ch;
    int root, son;
    //如果找到根便解码
    if(root = FindRoot(ht, n)){
        son = root;
        //利用哈夫曼树进行解码
        while(!feof(*cdfp)){
            ch = fgetc(*cdfp);
            if(ch == -1) break;
            if(ch == '0') son = (*ht)[son].LChild;
            else son = (*ht)[son].RChild;
            //如果到达叶子节点，便找到哈夫曼编码对应的信息，接着继续从根节点进行解码
            if((*ht)[son].LChild == 0 && (*ht)[son].RChild == 0){
                printf("%c", (*ht)[son].info);
                son = root;
            }
        }
    }
    fclose(*cdfp);
}

//统计不为零权值的个数，并且记录其下标到tw[]
int GetWeightId(int tw[], int w[]){
    int i, n = 0;
    for(i = 0; i < CHAR_KINDS; i++){
        if(w[i] > 0){
            tw[n++] = i;
        }
    }
    return n;
}

int main(){
    FILE *fp1;
    int n = 0, i;
    //w[CHAR_KINDS]用来统计每个字符出现的次数
    //因为ASCII码右256个数量较大，有的字符不出现，权值为0
    //则weightId[CHAR_KINDS]用来存储权值不为0的ASCII码
    int weightId[CHAR_KINDS], w[CHAR_KINDS];
    memset(w, 0, sizeof(w));
    for(i = 0; i < CHAR_KINDS; i++){
        weightId[i] = -1;
    }

    CountCharWeight(&fp1, w);

    HuffmanTree huffmantree;

    n = GetWeightId(weightId, w);
    printf("%d\n",n);
    HuffmanCode hc;
    CrtHuffman(&huffmantree, w, weightId, n);

    CrtHuffmanCode(&huffmantree, &hc, w, weightId, n);

    FILE *codefp;
    Coding(&fp1, &codefp, &hc);

    Decoding(&huffmantree, &codefp, w, n);
    printf("\n");
    return 0;

}

运行结果如下：

转载于:https://www.cnblogs.com/HyattXia/p/10049502.html

anjx84354
关注
对一篇文章进行按单词统计后哈弗曼编码解码
01-01
对一篇文章按单词统计，并通过统计的权重进行哈弗曼编码，通过编码对该编码进行解码，有界面。
词向量：哈夫曼（Huffman）编码
xunyishuai5020的博客
02-05 537
import numpy as np # class BinaryTreeNode(object): def __init__(self,value): self.left = None # 左子树 self.right = None # 右子树 self.value = value # the value of word # class HuffmanTreeNode(BinaryTreeNode): ''' co
《哈夫曼编码》（详细！！！）
热门推荐
C5408C的博客
11-07 1万+
给个关注吧
C++实现哈夫曼编码
12-20
哈夫曼编码是一种高效的数据压缩方法，通过构建特定的二叉树（哈夫曼树）来为输入数据的字符分配最短的唯一编码。在C++中实现哈夫曼编码通常涉及以下几个步骤： 1. **统计字符频率**： 首先，需要统计输入字符串中...
哈夫曼编码实现对文件的加密解密
12-03
哈夫曼编码是一种基于二叉树的数据压缩方法，由美国计算机科学家戴维·哈夫曼在1952年提出。在本项目中，我们利用哈夫曼编码实现了对文本文件的加密和解密功能，具体操作是针对ASCII字符集内的字符进行。以下是关于...
用C语言实现的哈夫曼编码和解码器的源码，包括统计汉字频率、构造哈夫曼树、求解哈夫曼编码以及编码结果的写入文件等功能
04-02
哈夫曼编码和解码器-中文汉字 1.设计目的 (1)复习并灵活掌握二叉树的各种存储结构和遍历方法， (2)了解静态链表，并掌握其构造方法。 (3)掌握哈夫曼树的构造过程和哈夫曼编码的求解方法 2.主要内容 (1)先统计某中...
信息论实验报告(实验四、哈夫曼编码)
06-09
信息论实验报告（哈夫曼编码） 信息论是现代通信系统的基础理论之一，哈夫曼编码是信息论中的一种重要编码方法。本实验报告的主要目的是为了让学生理解信源编码的意义，熟悉 MATLAB 程序设计，掌握哈夫曼编码的方法...
数据结构哈夫曼编码实验报告.doc
07-11
数据结构哈夫曼编码实验报告主要探讨了如何利用哈夫曼编码进行数据压缩与解压缩，以提高通信效率。哈夫曼编码是一种基于频率的前缀编码方法，它通过构建最优二叉树（哈夫曼树）来为不同的字符分配唯一的二进制编码，...
算法-哈夫曼编码
最新发布
纯洁的小魔鬼
06-25 2627
哈夫曼树能够根据字符出现的频率分配变长编码，使得高频字符使用较短的编码，低频字符使用较长的编码，从而最大程度地减少平均编码长度。这种自适应的编码方式使哈夫曼编码在很多实际应用中都能达到接近最优的压缩效果。频率越高的字符，经过的路径越短，则编码越短。最终的需要编码的所有字符都在叶子节点上。
使用哈夫曼树实现文本编码、解码
roc13718296531的博客
12-23 4064
使用二叉树存储结构的链表，进行构造二叉树，对指定字符串编码解码
输出给定文本的字符哈夫曼编码（基于树的二叉链存储结构）
weixin_44814196的博客
04-21 1902
目录一、问题描述二、实现思路三、解题代码四、运行结果 一、问题描述 给定一段文本，构造一棵哈夫曼树，给出文本中每个字符或词的编码。 二、实现思路 在该程序中，首先通过Frequency（）函数来分析输入文本中的字符数量以及其出现的次数，并将其次数作为权值。将文本信息存放到数组str中，数组的下标对应英文字母在英文字母表中的顺序，数组元素的值对应字母出现的次数。每当出现英文字母，就将其值加1.当扫描完文本后，将数组元素值不为0的数组元素转换为哈弗曼树的结点。 当生成哈弗曼树的结点后，调用函数CreateHT
c++实现基于哈夫曼编码的文本(中英混合)压缩和解压缩
yyl1025的博客
12-20 5206
c++实现基于哈夫曼编码的文本(中英混合)压缩和解压缩
C语言哈夫曼编码
程序设计
01-06 629
C语言哈夫曼编码 掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 二、实验内容、要求与注意事项 (1)实验内容：给定一篇文章，只含有英文大小写字母和空格，以.txt格式存储，统计该文件中各种字符的频率，对各字符进行Huffman编码，将该文件翻译成Huffman编码文件，再将Huffman编码文件翻译成源文件。 (2)实验要求：要求能够上机编辑、调试出完整的程序。 (3)注意事项：递归算法的灵活应用及多级指针的使用。 源码下载 链接：https://pan.baidu.com/s/184f00817q
哈夫曼编码的实现
君子以阅川的博客
06-09 672
要求：(C++和Python实现) 1. 从一个命名为text.txt只含有小写字母的文本文档中读取对应的字母的权重 2. 根据这些权重创建一个哈夫曼树 3. 根据这个哈夫曼树创建一个哈夫曼编码，并将其存到code.txt文本文档中 4. 输入一段英文字母，将它存入到soucrefile.txt文本中，并将其读入文件，在根据创建的哈夫曼编码输出其编码后的字符，存入到SourCode.txt文本中
Huffman编码、Shannon编码、Ｆａｎｏ编码——《小王子》文本压缩与解压
m0_53374676的博客
07-08 3001
Huffman编码、Shannon编码、Ｆａｎｏ编码——《小王子》文本压缩与解压
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值