哈夫曼编码译码器，压缩比（详细运行过程）

最新推荐文章于 2024-09-08 20:44:05 发布
最新推荐文章于 2024-09-08 20:44:05 发布
阅读量3.4k 收藏 27
点赞数
分类专栏： 数据结构学习 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1239854/article/details/106962114
版权

本人小辣鸡一枚，学校的一个数据结构作业。在此记录。
编译器：codeblocks
功能：
1.选择文件建立哈夫曼树
2.建立密码本，对文件进行编码
3.选择需要进行解码的文件解码
4.按位压缩方式压缩与解压，并且显示压缩比
运行操作及效果

目录结构：
目录结构

11.txt 必须有，剩下的随意，可以最初没有。让11.txt和自己的cpp文件放到一个文件夹里面。11.txt 里面随便写点什么，我写的内容是：
bbbbbbb
AAAAAA
cc
ddddd
eeeeeeeee

下面是我的运行过程，运行完之后，22.txt存的是编码文件，33.txt存的是编码文件解码后的文件，经过验证，和11.txt内容应该相同。44.txt是22.txt按位压缩后的结果，55.txt是44.txt解码后的结果，应该和22.txt内容相同。最后得到的压缩比应该大概是1/8
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<windows.h>
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<fstream>
using namespace std;
typedef struct HTNode{
    char data;
    int weight;
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char **HuffmanCode;
char myarr[1000]={NULL};
int mcnt;
int pData;//原文件
int nData;//压缩后的的文件
int multiple;
/*******************************************选择文件**************************************/
void ChooseFile(){
    char n[20];
    FILE *fp;
    char ch;
    int i=1;
    cout<<"输入要打开的文件"<<endl;
    cin>>n;
    fp=fopen(n,"r");
    if(fp==NULL)
        printf("打开失败!\n");
    else{
        fscanf(fp,"%c",&ch);
        while(!feof(fp)){
            myarr[i]=ch;
            fscanf(fp,"%c",&ch);
            i++;
        }
        fclose(fp);
        myarr[i]='\0';
    }
    pData=i-1;
    cout<<"打开原始文件"<<n<<"成功！";
    cout<<endl;
}
/*******************************************求文件中叶子结点的权值**************************************/
void Count(HuffmanTree &HT){//统计
    mcnt=0;
    int cnt[256]={0};
    for (int i=1;myarr[i]!='\0';i++)
        cnt[myarr[i]]++;
    for (int i=0;i<256;i++){
        if(cnt[i]>0){
            mcnt++;
        }
    }
    int m=2*mcnt-1;
    HT=new HTNode[m+1];
    int mcnt2=0;
    for (int i=0;i<256;i++){
        if(cnt[i]>0){
            mcnt2++;
            //cout<<"字符"<<(char)i<<"出现了"<<cnt[i]<<"次"<<endl;
            HT[mcnt2].weight=cnt[i];
            HT[mcnt2].data=(char)i;
        }
    }
}
/*****************************************哈夫曼编码******************************************************/
void HuffmanCODE(HuffmanTree HT, HuffmanCode &HC, int n){
    HC=new char *[n+1];
    char * cd=new char[n];
    cd[n-1]='\0';
    int start,c,f;
    for(int i=1;i<=n;i++)
    {
        start=n-1;
        c=i;
        f=HT[i].parent;
        while(f!=0)
        {
            start--;
            if(HT[f].lchild==c){
                cd[start]='0';
            }
            else{
                cd[start]='1';
            }
            c=f;
            f=HT[f].parent;
        }
        HC[i]= new char[n-start];
        strcpy(HC[i],&cd[start]);
    }
    for(int i=1;i<=mcnt;i++){
        cout<<HT[i].data<<"出现频度是："<<HT[i].weight<<" 编码为"<<HC[i]<<endl;
    }
    delete cd;
    ofstream file;
    char fl[100];
    cout<<"输入要写入的文件"<<endl;
    cin>>fl;
    file.open(fl,ios::out);
    for(int i=1;myarr[i]!='\0';i++){
        for(int j=1;j<=mcnt;j++){
            if(myarr[i]==HT[j].data){
                    //hc[j]字符串数组
                file <<HC[j];
                break;
            }
        }
    }
    file.close();
}
/*****************************************哈夫曼译码******************************************************/
void HuffmanDECODE(HuffmanTree HT,int n){
    char decode[1000];
    FILE *fp;  //创建一个文件指针*fp
    char ch;
    int mcnt3=0;
    char f1[20];
    cout<<endl<<"输入要解码哪个文件"<<endl;
    cin>>f1;
    fp=fopen(f1,"r");
    if(fp==NULL)
        printf("打开失败!\n");
    else{
        int i=0;
        fscanf(fp,"%c",&ch);
        while(!feof(fp)){
            decode[i]=ch;
           // putchar(ch);
            fscanf(fp,"%c",&ch);
            i++;
            mcnt3++;
        }
        fclose(fp);
        decode[i]='\0';
    }
    cout<<endl;
    ofstream file;
    char fl[100];
    cout<<"输入要写入的文件"<<endl;
    cin>>fl;
    file.open(fl, ios::out);
    int i,p;
    p=2*n-1;
    for(i=0;i<=mcnt3;i++){
        if(HT[p].lchild==0&&HT[p].rchild==0){
           // printf("%c",HT[p].data);
            file <<HT[p].data;
            p=2*n-1;
        }
        if(decode[i]=='0')
            p=HT[p].lchild;
        else if(decode[i]=='1')
            p=HT[p].rchild;
    }
    file.close();
    printf("译码成功\n");
}
/********************************找到父节点不为0的两个叶子结点**********************************/
void Select(HuffmanTree &HT,int i,int &s1,int &s2){
    s1=1;
    s2=1;
    int sm1=9999;
    int sm2=9999;
    for(int j=1;j<i;j++){
        if(HT[j].parent==0){
            if(HT[j].weight<sm1){
                sm2=sm1;
                sm1=HT[j].weight;
                s2=s1;
                s1=j;
            }
            else if(HT[j].weight<sm2){
                sm2=HT[j].weight;
                s2=j;
            }
        }
    }
}
/****************************************创建哈夫曼树**************************************/
void CreatHuffmanTree(HuffmanTree &HT){

    int m=2*mcnt-1;
    for(int i=1;i<=m;i++){
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
        if(i>mcnt){
            HT[i].weight=0;
        }
    }
    for(int i=mcnt+1;i<=m;i++){
        int s1=1,s2=1;
        Select(HT,i,s1,s2);
        HT[s1].parent=i;
        HT[s2].parent=i;
        HT[i].lchild=s1;
        HT[i].rchild=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;
    }
    cout<<"创建哈夫曼树成功！"<<endl;
    cout<<"字符   "<<"权值   "<<"双亲   "<<"左孩子   "<<"右孩子   "<<endl;
    for(int i=1;i<=m;i++){
        if(i<=mcnt){
            cout<<HT[i].data<<"        ";
        }
        else{
            cout<<"           ";
        }
        cout<<HT[i].weight<<"      ";
        cout<<HT[i].parent<<"      ";
        cout<<HT[i].lchild<<"      ";
        cout<<HT[i].rchild<<"        ";
        cout<<endl;
    }
}
/******************************二进制转十进制************************/
int binary2decimal(char str[]){
    int sum=0;
    int j=1;
    int pos = strlen(str) - 1;
    for(;pos>=0;pos--)
    {
        sum+=(str[pos]-'0')*j;
        j*=2;
    }
    return sum;
}
/*********************************压缩*********************************/
void Compress(){
    int mcount;
    char decode[1000];
    FILE *fp;  //创建一个文件指针*fp
    char ch;
    char f1[20];
    int mcnt3=0;//存储有多少个1 0
    cout<<endl<<"输入要打开哪个编码文件进行压缩？"<<endl;
    cin>>f1;
    fp=fopen(f1,"r");
    cout<<endl;
    if(fp==NULL)
        printf("打开失败!\n");
    else{
       // cout<<"编码文件的内容是："<<endl;
        int i=0;
        fscanf(fp,"%c",&ch);
            while(!feof(fp)){
                decode[i]=ch;
              //  putchar(ch);
                fscanf(fp,"%c",&ch);
                i++;
                mcnt3++;
            }
        fclose(fp);
        decode[i]='\0';
    }
    cout<<endl;
    //已经实现把所有二进制都读入到decode数组里了，下标从0开始

    //补齐0
    int k;
    if(mcnt3%8!=0){
        multiple=8-mcnt3%8;
        for(k=0;k<multiple;k++){
            decode[mcnt3+k]='0';
        }
        decode[mcnt3+k]='\0';
    }

    char data[10];
    data[8]='\0';
    ofstream file;
    char fl[100];//解压后.txt
    cout<<"输入把编码文件压缩到哪个文件"<<endl;
    cin>>fl;
    file.open(fl,ios::out|ios::binary);

    for(mcount=0;mcount<mcnt3+k;mcount++){
        data[mcount%8]=decode[mcount];//8个存到data数组
        if((mcount+1)%8==0){
            int result=binary2decimal(data);//变成十进制
            char res=(char)result;
            file<<res;
        }
    }
    file.close();

}
/*****************************十进制转二进制**************************/
int decimal2binary(int x,int &flag,int &digit){
    int p=1,y=0,yushu;
    int cont=0;
    while(1)
    {
        yushu=x%2;
        x/=2;
        y+=yushu*p;
        p*=10;
        if(x<2)
        {
            y+=x*p;
            break;
        }
    }
    int temp=y;
    while(temp!=0)
    {
        temp/=10;
        cont++;
    }
    if(cont!=8){
        flag=1;
        digit=8-cont;
    }
    return y;
}
/*******************************解压*****************************/
void Decompression(){
    int decode[1000];
    FILE *fp;  //创建一个文件指针*fp
    char ch;
    char f1[20];
    int mcnt3=0;//存储有多少个1 0
    cout<<endl<<"输入要解压哪个文件？"<<endl;
    cin>>f1;
    fp=fopen(f1,"r");
    cout<<endl;
    if(fp==NULL)
        printf("打开失败!\n");
    else{
        int i=0;
        fscanf(fp,"%c",&ch);
        while(!feof(fp)){
            decode[i]=ch;
            int data =ch;
            if(data<0){
                data=256+data;
                decode[i]=data;
                //mcnt3++;
            }
            fscanf(fp,"%c",&ch);
            i++;
            mcnt3++;
        }
        decode[i]='\0';
        nData=i;
        fclose(fp);
    }
    ofstream file;
    char fl[100];//解压后.txt
    cout<<endl<<"输入解压后的编码文件存在哪里？"<<endl;
    cin>>fl;
    file.open(fl,ios::out|ios::binary);
    char temp[1000];
    for(int i=0;decode[i]!='\0';i++){
        int flag=0;
        int dight=0;
        int res=decimal2binary(decode[i],flag,dight);
        if(flag==1){
            for(int y=1;y<=dight;y++){
                char c='0';
                file<<c;
            }
        }
        file<<res;
    }
    file.close();

    FILE *fp2;
    fp2=fopen(fl,"r");
    cout<<endl;
    if(fp2==NULL)
        printf("打开失败!\n");
    else{
        int i=0;
        fscanf(fp2,"%c",&ch);
        while(!feof(fp2)){
            if(i<(mcnt3)*8-multiple){
                temp[i]=ch;
                fscanf(fp2,"%c",&ch);
                i++;
            }
            else{
                break;
            }
        }
        fclose(fp2);
        temp[i]='\0';
    }
    ofstream file2;
    file2.open(fl,ios::out|ios::binary);
    for(int i=0;temp[i]!='\0';i++){
            file2<<temp[i];
    }
    file2.close();
}
void setColor(unsigned short ForeColor=4,unsigned short BackGroundColor=15){
    HANDLE handle=GetStdHandle(STD_OUTPUT_HANDLE);//获取当前窗口句柄
    SetConsoleTextAttribute(handle,ForeColor+BackGroundColor*0x10);//设置颜色
}
/*********************************压缩比*********************************/
void CompressionRatio(){
    cout<<"输入压缩前的文件是？"<<endl;
    ChooseFile();
    cout<<endl;
    int decode[1000];
    FILE *fp;  //创建一个文件指针*fp
    char ch;
    char f1[20];
    int mcnt3=0;//存储有多少个1 0
    cout<<endl<<"输入压缩后的文件是？"<<endl;
    cin>>f1;
    fp=fopen(f1,"r");
    cout<<endl;
    if(fp==NULL)
        printf("打开失败!\n");
    else{
        int i=0;
        fscanf(fp,"%c",&ch);
            while(!feof(fp)){
                decode[i]=ch;
                int data =ch;
                if(data<0){
                    data=256+data;
                    decode[i]=data;
                    //mcnt3++;
                }
                fscanf(fp,"%c",&ch);
                i++;
                mcnt3++;
            }
        decode[i]='\0';
        nData=i;
        fclose(fp);
    }
    double raTio=1.0*nData/pData*100;
    cout<<"压缩比是："<<nData<<"/"<<pData<<"="<<raTio<<"%"<<endl;
}
void HomePage(){
    cout<<"========================================================"<<endl;
    cout<<"*                *哈夫曼编码译码器*                    *"<<endl;
    cout<<"*             1、选择需要进行编码的文件                *"<<endl;
    cout<<"*             2、建立哈夫曼树                          *"<<endl;
    cout<<"*             3、建立密码本并对文件编码                *"<<endl;
    cout<<"*             4、选择需要进行解码的文件并解码          *"<<endl;
    cout<<"*             5、按位压缩方式对文件进行压缩            *"<<endl;
    cout<<"*             6、显示压缩比                            *"<<endl;
    cout<<"*             7、解压                                  *"<<endl;
    cout<<"*             8、退出                                  *"<<endl;
    cout<<"========================================================"<<endl;
}
main(){
    setColor();
    //system("color 3");
    HuffmanTree hf;
    HuffmanCode hc;
    while(1){
        HomePage();
        cout<<"输入您想进行的操作是(1-8):";
        int n;
        cin>>n;
        if(n==1){
            ChooseFile();//第一个功能
        }else if(n==2){
            Count(hf);
            CreatHuffmanTree(hf);//第二个功能
        }else if(n==3){
            HuffmanCODE(hf,hc,mcnt);//第三个功能
        }else if(n==4){
            HuffmanDECODE(hf,mcnt);//第四个功能
        }else if(n==5){
            Compress();//压缩
        }else if(n==6){
            CompressionRatio();
        }else if(n==7){
            Decompression();
        }else if(n==8){
            return 0;
        }else{
            cout<<"输入错误！";
        }
        system("pause");
        system("cls");
    }
}

哈夫曼树网上有很多的讲解。
压缩和解压的代码不多。。。
8位是256个（0-255）。。。然后char存字符。。存0-255的数字，刚好是8位，2的8次方。
所以把编码后的每8位都变成一个十进制的数字，存在char中，然后翻译再对照后翻译回十进制，再变成二进制。。。如果最后不足八位，补齐0，补成8位，解码时候注意去掉0。

欢迎各位大佬多多指教。

小焦爱学习
关注
专栏目录
实验三 Huffman编解码算法实现与压缩效率分析
GemRuswj的博客
06-11 1185
一、Huffman编解码原理
哈夫曼编码压缩解压缩实现&不同类型文件压缩比的测试
YiShi's Blog
12-30 1万+
压缩原理及步骤&&压缩比的计算压缩原理及步骤压缩的第一步： 将一个文件以各个字符出现的次数为权值建立哈夫曼树，这样每个字符可以用从树根到该字符所在到叶子节点的路径来表示。(左为0,右为1) 压缩第二步： 哈夫曼编码有一个很重要的特性：每个字符编码不会成为另一个编码的前缀。这个特性保证了即使我们把不同长度的编码存在一起，仍然也可以把它们分离开，不会出现认错人的冲突。 那么我们就可以把所有
基于huffman树的文件压缩项目以及相关测试
最新发布
m0_71808911的博客
09-08 1079
项目采用Huffman编码的方式进行文件压缩与解压缩。主要原理是通过Huffman编码来表示字符，出现次数多的编码短，出现次数少的编码长，这样整体而言，所需要的bit位是减少的，就实现了文件压缩功能。读取文件中的字符出现次数，构建Huffman树，然后解析这个字符的每一位，遇到一个叶子结点，就代表还原了一个字符，这时就将这个字符写到解压缩文件里。注意当大部分字符出现的频率都差不多时，Huffman压缩的效率比较低。
霍夫曼树之计算压缩比
weixin_30896511的博客
07-03 2082
昨天做了那道霍夫曼树的题目(HDU1053)之后,发现如果只需要计算编码后的长度则无需真正建树. #include <algorithm> using namespace std; char buffer[1024]={0}; int q[1024]={0}; int main() { while(scanf("%s",buffer)!=EOF &am...
huffman 压缩
lzljy的专栏
12-19 289
一、huffman二叉树原理 1、将数组按每个数值的权重大小，最小两个权重的数值合并组成一个二叉树，新的二叉树节点值取代原有的两个数值，成为数组的新值，并具有新的权重（原权重相加）； 2、新的数组继续取最小权重形成新的二叉树，取代原两数，形成新数组，以此不断循环，直至数组合并成一个值，并形成一个二叉数"森林"——即以最后一个数为根，每层分叉形成两叉； 3、每个数值根据二叉树路径（0,1)形成...
赫夫曼编码解压缩
ALin_Think的博客
03-26 421
赫夫曼编码 基本介绍 1、赫夫曼编码也翻译为哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法 2、赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。 3、赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间 4、赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码 原理 1、构建赫夫曼树 1...
课设哈夫曼编码译码器.zip
06-08
在这个课程设计中，我们将重点讨论哈夫曼编码的原理、构建过程以及C++实现。 1. **哈夫曼编码原理**： - **编码构建**：首先统计输入文本中每个字符的出现频率，然后用这些频率创建一个哈夫曼树。这个过程是通过...
哈夫曼编码译码器（数据结构）
12-09
在给定的项目中，“哈夫曼编码译码器”是一个用C++实现的工具，用于处理哈夫曼编码和解码的过程。首先，这个程序能够创建哈夫曼树，这是哈夫曼编码的关键步骤。创建哈夫曼树时，会根据输入文件中各字符的出现频率来...
哈夫曼编码/译码器数据结构课程设计
12-13
设计一个哈夫曼编码/译码系统，对一个文本文件中的字符进行哈夫曼编码，生成编码文件（后缀名.cod）；...（5）把哈夫曼编码用二进制位紧缩到一个变量中，利用位运算进行真正的数据压缩，并求压缩比。（此选项选作）
哈夫曼编码译码器实验报告免费.docx
07-05
【哈夫曼编码译码器】是数据压缩领域的一种高效编码技术，主要应用于文本和图像等数据的压缩。本实验报告主要围绕哈夫曼编码的创建、存储和解码进行探讨，涉及到的数据结构和算法设计对于理解计算机科学，尤其是...
哈夫曼编码解码的可视化界面实现
12-24
在实际应用中，哈夫曼编码常用于文本、图像和音频的压缩，因为它能够提供较高的压缩比，特别是在数据中存在大量重复字符的情况下。通过这个可视化界面，学习者可以更直观地理解哈夫曼编码的工作原理，并进行实践操作...
哈夫曼编码解码的实现及运行截图（C语言）
11-01
哈夫曼编码解码的实现及运行截图（C语言编写）
哈夫曼树、哈夫曼编码与压缩比
热门推荐
土味儿
10-25 2万+
1、哈夫曼树 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度 构造哈夫曼树 2、哈夫曼编码 3、压缩比 案例分析： 已知某文档包含5个字符。每个字符出现的频率如下表所示。采用霍夫曼编码对该文档压缩存储，则单词“cade”的编码为（ (1) ），文档的
编码压缩介绍
u012117034的博客
05-20 2077
从前文我们知道，YUV420 已经比 YUV444 数据少了一半，而且体验几乎感受不到差别。如下： 从上图可以看到，虽然数据减少了一般，但是一张 1080p 的图片也有 3038kb 的大小，也就是 3Mb 大小，动画看起来流畅，需要一秒播放 24 张图片，1个小时的电影大小如下：3 *24 * 60 * 60 = 2592003∗24∗60∗60=259200因此，1小时的YUV420 的电影，需要 253G 空间来存储，截止 2022 年，一个普通的硬盘，才500G大小，只能存两部电影。所以 即使
哈夫曼编码压缩比问题：POJ1521 熵
qq_48988844的博客
09-13 661
题目描述： An entropy encoder is a data encoding method that achieves lossless data compression by encoding a message with "wasted" or "extra" information removed. In other words, entropy encoding removes information that was not necessary in the first place t
哈夫曼编码压缩率计算_深入浅出说监控---------网络硬盘录像机硬盘大小的选用和计算...
weixin_39836943的博客
11-10 459
要计算存储硬盘大小，首先要了解两方面监控摄像机的工作流程和视频的压缩方式。监控摄像机的工作流程数字摄像机工作原理是通过图像传感器(CMOS或CCD)将视频图像转为模拟信号，模拟信号经过模数转换器(A/D)转换为数字信号，而后经过编码压缩，通过网络接口输出到存储显示设备。视频的压缩方式目前市场上的网络摄像机的编码主要有H.264和H.265两种视频编码标准。所谓H.264和H.265，就是编码压缩...
哈夫曼编码压缩率计算_北理工计算机813计算机基础考研经验
weixin_39951396的博客
10-22 466
北理工计科学硕上岸经验分享(2020年)北京理工大学计算机科学与技术学术型硕士的专业课编号是813，由数据结构(120分)和计算机组成原理(30分)两部分组成，接下来会对这两部分列出一些我自己的经验。数据结构ààààà推荐书目：《数据结构》(严蔚敏)对于数据结构的复习，总的来讲是推荐以严版教材为主，因为这本书写的极为细致，甚至是无微不至，对考点实现了全覆盖(对专硕和学硕都是如此)，书上对...
哈夫曼编码压缩率计算_程序员必备——哈夫曼树的基本概念
weixin_39956022的博客
10-21 3008
问题： 给定N个带权值的叶子节点，如何构造出一个带权路径最小的二叉树？答：哈夫曼树（Huffman Tree） 在数据结构理论中，哈夫曼树又称为最优树，相关的知识点还有哈弗曼编码等。在正式介绍哈夫曼树之前，需要知道下面的知识点：（1）节点路径 按照规定，将树中一个节点到另一个节点所经历的分支，称为节点路径，比如上图中节点A到节点E的路径为ABE。（2）路径长度 ...
哈夫曼编码译码器实现与交互演示
哈夫曼编码译码器实验是《数据结构》课程中的一个重要实践环节，主要目标是让学生理解并掌握哈夫曼编码算法，包括哈夫曼树的构建和编码生成方法。在这个实验中，学生需实现一个程序，可以处理以下关键任务： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值