Huffman 编码压缩解压

最新推荐文章于 2024-04-17 12:57:30 发布
最新推荐文章于 2024-04-17 12:57:30 发布
阅读量107 收藏 1
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：http://www.cnblogs.com/drdh/p/7782770.html
版权
说明
  1. 某技校数据结构课作业

  2. 目前的算法只对有规律的文件有效。

    此处的规律指的是0x00到0xff的分布不均匀

    txt文件不论汉字还是英文有效。jpg,pdf压缩无效。

  3. 以下内容毫无逻辑，不具有参考价值。

参考资料
思路建立
1. 读写二进制文件
FILE *fi=fopen("origin.data","rb");
FILE *fo=fopen("zip.data","wb");

unsigned char c;
fread(&c,sizeof(unsigned char),1,fi);
fwrite(&c,sizeof(unsigned char),1,fo);

fclose(fi);
fclose(fo);

其他的文件操作，比如rewind，以及对数组、结构体读写略。

2. 权重
int *Weight[256]={0};

  c : File
  Weight[c]++

仅对权重不为0的编码

3. 编码后
char *HuffmanCode[256];256    //malloc分配各自的空间，每个编码的结尾为'\0'
HuffmanCode[c]    //c是 8 bits 可进行位操作

当前所得，密码本

HuffmanCode[c]="11110"    //位数不定，结尾是'\0'

分析
一个无符号数(0~255)，本身是

数 123
位 7b 01111011
字符 '{'
具体 printf("%d,%x,%c",123,123,123);

可能用到的字符串操作

strncpy(char *d,char *s,int n);
strcpy(char *d,char *s);

strncat()
strcat()

strchr(char *s,char c)
strstr(char *s1,char *s2)

strcmp(char *s1,char *s2)
strncmp()

strlen()

动态读取文件

使 unsigend char c=220   //或0xdc 或11011100
变成 unsigned char s[]="11011100"

    i:7~0
        c=(c<<1)+s[i]-'0'

将c写入文件
这之前先写入末尾补0个数(用一个int 占位)，以及权重(便于解码)

4. 解压

读取权重，构建Huffman树
解码

unsigned char c=220    //11011100   0xdc
unsigned char str[9]
str[8]='\0'
   i:7~0
     str[i]=(c&0x80) ? '1':'0'
     c<<=1

解压用数逐位判断分支

压缩文件结构

int zero
0x00 int
...
0xff int
码
5. 说明

位运算将c定义为unsigned char 否则解释为负
编码用前pow(2,31)-1个byte，或者考虑动态构建。

代码说明

代码位置


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

const char originf[]="origin.data";
const char compressf[]="zip.data";
const char uncompressf[]="finally.data";


int *Weight;
void Weigh()
{
    Weight=(int *)malloc(256*sizeof(int));
    int i;
    int allCount=0;
    int max=pow(2,31)-1;
    for(i=0;i<256;i++)
        Weight[i]=0;

    FILE * fp=fopen(originf,"rb");
    unsigned char c;
   // rewind(fp);
   fread(&c,1,1,fp);
    while(!feof(fp))
    {
       // fread(&c,1,1,fp);
        Weight[c]++;
        allCount++;
        fread(&c,1,1,fp);
        if(allCount>max-10)
            break;
    }
    
   // if(feof(fp))
   //     Weight[c]--;
    fclose(fp);
}

typedef struct{
    int w;
    int p,l,r;
}HTNode;

unsigned char **HuffmanCode;//code
HTNode *Root;      //tree
//int *Weight;

void SelectMin2(int Count,int Total,int *s1,int *s2)    //select 2 min weight , parent=0, weight !=0
{
    int min=Count+1;
    int i;
    *s1=789;
    *s2=789;
    for(i=1;i<=256+Total-2;i++)
    {
        if(Root[i].w &&  (!Root[i].p) &&  Root[i].w<min)
        {
            min=Root[i].w;
            *s1=i;
        }
    }
    
    Root[*s1].p=1;
    
    min=Count+1;
    for(i=1;i<=256+Total-2;i++)
    {
        if(Root[i].w && (!Root[i].p) && Root[i].w<min)
        {
            min=Root[i].w;
            *s2=i;
        }
    }
    Root[*s2].p=1;

}

int HuffmanCoding()
{
   // Weigh();
    int i;
    int Total=0;
    int Count=0;
    for(i=0;i<256;i++)
        if(Weight[i])
        {
            Total++;
            Count+=Weight[i];
        }
   // printf("%d\n",Count);
    int m=256+Total-1;   //total
    Root=(HTNode*)malloc((m+1)*sizeof(HTNode));    //tree

    //initial the tree
    
    for(i=1;i<=256;i++)
    {
        Root[i].w=Weight[i-1];
        Root[i].p=0;
        Root[i].l=0;
        Root[i].r=0;
    }

    for(;i<=m;i++)
    {
        Root[i].w=0;
        Root[i].p=0;
        Root[i].l=0;
        Root[i].r=0;
    }

    //build huffman tree
    for(i=257;i<=m;i++)
    {
        int s1,s2;
        SelectMin2(Count,Total,&s1,&s2);

        if(s1==s2)
            printf("\n\n\n%d   %d\n\n\n",i,s1);
        Root[s1].p=i;
        Root[s2].p=i;
        Root[i].l=s1;
        Root[i].r=s2;
        Root[i].w=Root[s1].w+Root[s2].w;
    }

    //get codes
    HuffmanCode=(unsigned char **)malloc((256)*sizeof(unsigned char*));
    unsigned char *temp=(unsigned char*)malloc((256*sizeof(unsigned char)));   //temp work place
    temp[256-1]='\0';   //end

    for(i=1;i<=256;i++)
    {
        if(!Root[i].w)    //weight ==0 --> p==0
        {
            HuffmanCode[i-1]=(unsigned char *)malloc(sizeof(unsigned char));
            *HuffmanCode[i-1]='\0';
        }
        else
        {
            int start=256-1;
            int c,f;
            for(c=i,f=Root[i].p;f!=0;c=f,f=Root[f].p)
            {
                if(Root[f].l==c)
                    temp[--start]='0';
                else temp[--start]='1';
            }
            HuffmanCode[i-1]=(unsigned char*)malloc((256-start)*sizeof(unsigned char));
            strcpy(HuffmanCode[i-1],&temp[start]);
        }
    }
    free(temp);
    return Total;
}

void Compress()
{
    Weigh();
    HuffmanCoding();
    FILE *fi=fopen(originf,"rb");
    FILE *fo=fopen(compressf,"wb+");

    int zero=0;
    fwrite(&zero,sizeof(int),1,fo);

    fwrite(Weight,sizeof(int),256,fo);

    unsigned char c;
    unsigned char w[9]={0};
    fread(&c,1,1,fi);
    unsigned char work[256]={0};
    unsigned char copy[256]={0};
    unsigned char write=0;
    while(!feof(fi))
    {
        strcat(work,HuffmanCode[c]);
        while(strlen(work)>=8)
        {
            strncpy(w,work,8);
            w[8]='\0';

            strcpy(copy,&work[8]);
            strcpy(work,copy);

            int i;
            write=0;
            for(i=0;i<=7;i++)
                write=(write<<1)+w[i]-'0';

            fwrite(&write,1,1,fo);
        }
        fread(&c,1,1,fi);

    }

    if(strlen(work))
    {
        strcpy(w,work);
        int len=strlen(w);
        unsigned char temp[9]="00000000";
        zero=8-len;
        strncat(w,temp,zero);
        int i;
        write=0;
        for(i=0;i<=7;i++)
            write=(write<<1)+w[i]-'0';
        fwrite(&write,1,1,fo);
        rewind(fo);
        fwrite(&zero,sizeof(int),1,fo);
    }

    fclose(fi);
    fclose(fo);

    int i;
    
        for(i=0;i<256;i++)
        printf("%x   %d   %s\n",i,Weight[i],HuffmanCode[i]);
        
    for(i=0;i<256;i++)
    {
        free(HuffmanCode[i]);
    }
    
    
    free(HuffmanCode);
    free(Weight);
    free(Root);
}

void Uncompress()
{
    FILE *fi=fopen(compressf,"rb");
    FILE *fo=fopen(uncompressf,"wb");

    int zero;
    fread(&zero,sizeof(int),1,fi);
    Weight=(int *)malloc(256*sizeof(int));
    fread(Weight,sizeof(int),256,fi);

   int  Total= HuffmanCoding();
   int  m=256+Total-1;

   int i;
   int maxCode=0;
   for(i=0;i<256;i++)
   {
       int len=strlen(HuffmanCode[i]);
       if(len>maxCode)
           maxCode=len;
   }

   unsigned char store[256]={0};
   unsigned char work[9]={0};
   unsigned char copy[256]={0};
   work[8]='\0';
   unsigned char c1,c2;
   fread(&c1,1,1,fi);
   fread(&c2,1,1,fi);
   while(!feof(fi))
   {
       int j;
       for(j=0;j<=7;j++,c1<<=1)
       {
           if(c1&0x80)
               work[j]='1';
           else
               work[j]='0';
       }
       strcat(store,work);

       while(strlen(store)>=maxCode)
       {
           int cur=m;
           int k=0;
           while(Root[cur].r)
           {
               if(store[k]=='0')
                   cur=Root[cur].l;
               else
                   cur=Root[cur].r;
               k++;
           }
           unsigned char write=cur-1;
           fwrite(&write,1,1,fo);

           strcpy(copy,&store[k]);
           strcpy(store,copy);
       }
       c1=c2;
       fread(&c2,1,1,fi);
   }



   work[8-zero]='\0';
   int j;
   for(j=0;j<=7-zero;j++,c1<<=1)
   {
       if(c1&0x80)
           work[j]='1';
       else
           work[j]='0';
   }
   strcat(store,work);
   while(strlen(store))
   {
       int cur=m;
       int k=0;
       while(Root[cur].r)
       {
            if(store[k]=='0')
                cur=Root[cur].l;
            else
                cur=Root[cur].r;
            k++;
        }
        unsigned char write=cur-1;
        fwrite(&write,1,1,fo);

        strcpy(copy,&store[k]);
        strcpy(store,copy);
   }
   
    for(i=0;i<256;i++)
    {
        free(HuffmanCode[i]);
    }
    free(HuffmanCode);
    free(Weight);
    free(Root);

    fclose(fi);
    fclose(fo);
}


int main()
{
    Compress();
    Uncompress();
}
其他

zip压缩算法详细分析及解压实例解释

转载于:https://www.cnblogs.com/drdh/p/7782770.html

weixin_30733003
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Huffman编码实现压缩、解压文件
Christine的专栏
11-14 4706
Huffman编码：根据词频构建Huffman树，实现对文本的前缀编码。 1、统计文本中每个字符出现的次数，放入优先队列中，构建一棵空的二叉树； 2、取出频率最小的两个字符a、b，字符a、b的频率分别作为此二叉树的左右结点，左结点的编号为1，右结点的编号为0，其频率之和（fa + fb）作为该二叉树的父亲节点，放入优先队列，并将fa  、fb 从优先队列中除去； 3、重复第二步操作，直至
Huffman编码解压缩的通俗讲解
TellH的博客
04-30 9515
前言好久没写博客了，主要是各种事缠着，难以抽出时间。这两个月以来，由于项目需要，我也逼着自己学到了很多，什么java后台，web前端，还有万恶的OpenCV图形处理……，呵呵，全栈:( 。但对Android的学习我始终不肯放下。但是今天这篇博客不是关于Android的，而是算法的相关应用–哈夫曼压缩。这是数据结构与算法实验里面的一个项目，网上关于这方面的资料很多，但大多数博客都是随便讲讲然后扔下代码
哈夫曼压缩与解压缩
热门推荐
飞鸿踏雪泥的博客
08-13 3万+
哈夫曼压缩与解压缩 目录 哈夫曼压缩与解压缩 一：引言 二：主要技术点 三：过程介绍 1、压缩： 2、解压缩 四：详细分析 一：准备过程 二：压缩 三：解压缩 五：结果演示 六：总结 七：源码地址 一：引言 之前的两个贪吃蛇和巨大数的练习，总体来说难度不大，有好的算法和比较新颖的微译码补码。但是，哈夫曼压缩与解压缩可以说难度比前两个大得多，涉及的知识面更加广。做完这...
用Huffman树实现文件压缩与解压
CC_clear的博客
08-07 3752
用Huffman树实现文件的压缩与解压 我们先来了解一下什么是Huffman树？ 我们平常所使用的Zip等压缩工具都是借助Huffman树实现的，Huffman是一种特殊的二叉树，它是一种加权路径最短的二叉树， 因此也称为最优二叉树。 （下面用一幅图来说明） 它们的带权路径长度分别为：图1： WPL=3*2+4*2+2*2+10*2=48 图2： WPL=3*3+2*3+4*
用Huffman树实现文件压缩并解压
T_tangcのblog
04-26 868
一、前言        如果你学习数据结构，就一定会学到Huffman树，而Huffman编码实际上上就是zip压缩的核心部分，所以，如果已经学习了Huffman树，为何不尝试写一个压缩程序出来呢？如果你没有学习Huffman树，那咱们就一起先学习一下Huffman树吧。二、Huffman树压缩文件定义：Huffman树，又称为最优二叉树，是加权路径长度最短的二叉树。建立：        这样建立...
霍夫曼编码的压缩与解压
an_gentle_killer的博客
08-16 1753
赫夫曼编码 百度定义：哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码） 在了解赫夫曼编码前先了解一下 定长编码：太长 变长编码：多义性 赫夫曼编码： ...
Huffman编码文件的压缩与解压程序[2024-04-17]
最新发布
code helper
04-17 368
实现解压功能，能够将压缩文件还原为原始文本文件。确保解压后的文件与原始文件内容一致。考虑并实现一些性能优化策略，例如频繁字符的缓存、编码表的持久化等，以提高压缩速度。实现Huffman编码算法，能够根据输入的文本生成对应的Huffman编码表。使用Huffman编码对文本文件进行压缩，并生成相应的压缩文件。提供清晰的用户文档，解释如何使用压缩器以及理解压缩算法的原理。提供用户界面或命令行接口，允许用户选择待压缩的文本文件。C语言实现基于Huffman编码的文件压缩与解压程序。
Huffman编码压缩解压文件
06-20
Huffman编码对文件进行操作，包括压缩和解压。是数据结构与算法分析课程设计的其中一个实验的源代码。
huffman编码实现压缩与解压文件
02-20
5. **保存编码表**：编码后的文件需要保留Huffman编码表以便解压。编码表可以存储为额外的字节流，或者通过某种方式编码到压缩文件的开头。 6. **解压缩**：解压缩时，首先读取并重建Huffman编码表。然后，按照编码...
Huffman 编码图像无损压缩和解压缩 Python示例代码 哈夫曼编码
08-13
本程序实现了利用 Huffman 编码对图像进行无损压缩和解压缩。Huffman 编码是一种基于字符出现频率构建相应前缀码的无损数据压缩算法。 使用方法： 1. 需要安装 OpenCV 和 Numpy 库： pip install opencv-python ...
HUFFMAN解压缩工具
08-01
HUFFMAN解压缩工具 用VC做的，基本上完成了，速度尽可能的做了提高。核心在于读写文件的处理
Huffman 压缩解压缩 Java实现
08-31
使用Java 语言实现了Huffman编码的压缩和解压缩，能够实现对Ascii 文档的压缩和解压缩，目前尚不支持对二进制文档进行压缩
使用Huffman对文件进行压缩和解压缩
01-12
使用java语言实现Huffman对任意文件做到压缩和解压缩，压缩后的文件只能通过解压缩来解压后才能读取
huffman压缩源代码实现
10-12
c++实现huffman压缩源代码，全自己，有较大的学习价值
Huffman压缩解压系统设计.zip
07-08
根据霍夫曼（哈夫曼）算法写的应用系统，含C++版本和Java版本。C++版本是按照山大软件学院数据结构课设题目写的。Java版本是自己写的更完善的、侧重于解压压缩的项目。开发了一个月，稳定性良好，UI也不错，速度上做了不少优化。
Huffman编码压缩，解压缩工具，Pyqt5，Python
07-12
Huffman 压缩解压工具， 基于 pyqt5 图形程序开发框架，采用 python 实现了 Huffman 编码压缩/解压算法，实现了对二进制文件进行压缩编码，和解压缩译码功能，界面交互简单友好，易于操作。 详细说明：...
基于霍夫曼(Huffman)图像编码的图像压缩和重建-含Matlab代码.docx
05-08
5. Huffman编码的优势与限制： 优势在于其无损特性，解压后能够完全恢复原始数据。然而，霍夫曼编码不适合压缩具有复杂结构或随机性的图像，因为这些图像的像素分布往往不均匀，压缩效果可能不如其他有损压缩算法如...
哈夫曼编码&文件压缩和解压
m0_56280646的博客
05-07 4582
赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码。
霍夫曼编码实现文件的压缩、解压
YiGeiGiaoGiao的博客
10-28 1398
java实现霍夫曼编码解码
Huffman编码实现文本压缩与解压详解
"这篇资源是关于使用HUFFMAN编码进行数据压缩和解压缩的一个项目分享。作者提到，HUFFMAN编码是一种广泛应用于数据压缩领域的算法，尤其在JPEG和MP3等多媒体编码中起到重要作用。文章内容包括数据压缩的意义、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值