最简单文件压缩程序huffman

最新推荐文章于 2024-09-16 18:31:59 发布
最新推荐文章于 2024-09-16 18:31:59 发布
阅读量121 收藏
点赞数
分类专栏： C++入门/成长之路 文章标签： 数据结构 算法 J# Blog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/westice/article/details/83768152
版权

   正在恶补数据结构，今天看到了二叉树，huffman编码，发现压缩程序很有意思，就按照huffman的编码思想实现了一个，没有经过算法改进，但是没有用第三方库，还能压缩一点空间，花了一天写完的。编码效率还是很菜。

 

只要调用compress  和decompress就可以压缩，解压，当然不是zip和rar,离他们还差十万八千里啊！

 

 

#include <iostream>

#define LEFT 0
#define RIGHT 1

using namespace std;

typedef struct huffmanTreetype{
    huffmanTreetype(){
       weight = 0;
       huffmancode = NULL;
       codelen = 0;
       list_next = NULL;
       list_prev = NULL;
       parent = NULL;
       left_child = NULL;
       right_child = NULL;   
       isleafnode = true;
       l_or_r = 2;
       frequency = 0;
    }    
    void printCode(){
       cout<<ch<<"  huffmancode:";
       for(int i = 0 ;i < codelen; i++){
           cout<<(int)huffmancode[i];
       }       
       cout<<endl;
    }    
    char *huffmancode;
    char codelen;
    char l_or_r;
    unsigned char ch;
    bool isleafnode;
    float weight;
    int frequency;
    struct huffmanTreetype *list_next,*list_prev,*parent,*left_child,*right_child;
    
}huffmanTree;    

huffmanTree *leaflist_header = NULL; //叶子节点头
huffmanTree *listtree_header = NULL; //huffman树 
int compress_len = 0;  //压缩后字节总长 
int compresscount = 0;
float compressprogress = 0; //压缩进度 

//加入链表末尾 
void appendList(huffmanTree *const header,huffmanTree *node){
    huffmanTree *iterator = header;
    while(iterator->list_next != NULL){
        iterator = iterator->list_next;
    }    
    iterator->list_next = node;
    node->list_prev = iterator;
    node->list_next = NULL;
}    

//断开链表中的元素，但不销毁
huffmanTree*  cutElement(huffmanTree *const header,huffmanTree *node){
    huffmanTree *iterator = header;
    huffmanTree *newheader = header;
    bool modify = false;
    while(iterator != NULL){
        if(iterator == node){
            modify = true;
            huffmanTree *node_prev = iterator->list_prev;
            huffmanTree *node_next = iterator->list_next;
            if(node_prev != NULL){
               node_prev->list_next = node_next;   
            }    
            if(node_next != NULL){
               node_next->list_prev = node_prev;   
            }    
            if(iterator == header){
               newheader = iterator->list_next;
               newheader->list_prev = NULL;
            }    
        }
        iterator = iterator->list_next;    
    }
    //把节点从链表中完全断开 
    if(modify){
        node->list_prev = NULL;
        node->list_next = NULL;    
    }        
    return newheader;
}    

//链表长度 
int listlength(huffmanTree *const header){
    huffmanTree *iterator = header;
    int len = 0;
    while(iterator != NULL){
        len++;
        iterator = iterator->list_next;
    }    
    return len;
}    

//打印链表 
void printlist(huffmanTree *const header){
    huffmanTree *iterator = header;
    while(iterator != NULL){
        cout<<"("<<iterator->ch<<" "<<iterator->weight<<")  ";
        iterator = iterator->list_next;
    }    
    cout<<endl;
}    

//先序取出叶子节点 
void preOrderTree(huffmanTree *rootnode){
   if(rootnode != NULL){
      if(rootnode->isleafnode){
          //cout<<rootnode->ch<<"  ";
         //如果为叶子节点，把它加入叶子链表中
          if(leaflist_header == NULL){
              leaflist_header = rootnode;
          }else{
              appendList(leaflist_header,rootnode);   
          }        
      }    
      preOrderTree(rootnode->left_child);
      preOrderTree(rootnode->right_child);   
   }    
}    

//设置huffman编码
void setfuffmanCode(huffmanTree *const listheader){
    huffmanTree *list_iterator = listheader;
    huffmanTree *tree_iterator = NULL;
    while(list_iterator != NULL){
        //左支为0，右支为1 
        tree_iterator = list_iterator;
        //首先要计算编码有多少位 
        while(tree_iterator->parent != NULL){
            list_iterator->codelen++;
            tree_iterator = tree_iterator->parent;
        }//tree while    
        //为code分配空间
        list_iterator->huffmancode = new char[list_iterator->codelen];
        tree_iterator = list_iterator;
        
        compress_len += (list_iterator->frequency * list_iterator->codelen);
        for(int i = list_iterator->codelen - 1;i >= 0 ;i--){
            list_iterator->huffmancode[i] = tree_iterator->l_or_r;
            tree_iterator = tree_iterator->parent;
        }        
        //list_iterator->printCode();
        
        list_iterator = list_iterator->list_next;
    } //list while   
    int leavetemp = compress_len%8;
    compress_len = compress_len/8;
    if(leavetemp != 0){
       compress_len ++;    
    }
}     

//选中剩下节点中两个最小的 
huffmanTree* findLasttwo(huffmanTree * header,huffmanTree **lasttwo){
    huffmanTree *iterator = header;
    lasttwo[0] = iterator;
    iterator = iterator->list_next;
   
    while(iterator != NULL){
        if(iterator->weight < lasttwo[0]->weight){
            lasttwo[0] = iterator;
        }    
        iterator = iterator->list_next;
    }    //end while
    //找倒数第二的 ,先解除最小的，最后加上最小的 
    header = cutElement(header,lasttwo[0]);
    iterator = header;
    lasttwo[1] = iterator;
    iterator = iterator->list_next;
     
    while(iterator != NULL){
        
        if(iterator->weight < lasttwo[1]->weight){  
             lasttwo[1] = iterator;
        }    
        
        iterator = iterator->list_next;
    }    //end while
    
    appendList(header,lasttwo[0]);
    return header;
}    

//根据统计数据创建huffman树 
void createHuffTree(int *statistics){
     //构造huffman树 
   int total_frequency = 0;
   for(int i = 0 ;i < 256 ;i++){
       total_frequency += statistics[i];
   }    
   for(int i = 0 ;i < 256 ;i++){
      if(statistics[i] != 0){ 
        //计算权值 
        huffmanTree *node = new huffmanTree;
        node->ch = i;
        node->frequency = statistics[i];     
        node->weight = statistics[i]/(float)total_frequency; 
        if(listtree_header == NULL){
            listtree_header = node;   
        }else{    
            appendList(listtree_header,node);
        }    
        //cout<<(char)i<<": weight  "<<node->weight<<endl;
      }    
   }    
   
   //直到链表中只有一个元素才停止构造树
   //选中剩下节点中两个权值非0最小的构造新节点 
   huffmanTree* lasttwo[2];
   //printlist(listtree_header);
   
   while(listlength(listtree_header) >= 2){//链表中至少有两个元素 
       listtree_header = findLasttwo(listtree_header,lasttwo);
       //cout<<"listlen:"<<listlength(list_header)<<endl;
       //cout<<"last two 0 :"<<lasttwo[0]->ch<<" 1:"<<lasttwo[1]->ch<<endl;
       //开始生成树结构 
       huffmanTree *node = new huffmanTree;
       lasttwo[0]->parent = node;
       lasttwo[0]->l_or_r = LEFT;
       lasttwo[1]->parent = node;
       lasttwo[1]->l_or_r = RIGHT;
       node->ch = '#';
       node->isleafnode = false;
       node->weight = lasttwo[0]->weight + lasttwo[1]->weight;
       node->left_child = lasttwo[0];
       node->right_child = lasttwo[1];
           
       //将链表重新链接好,可能把链表头都合并了 
       appendList(listtree_header,node);
       listtree_header = cutElement(listtree_header,lasttwo[0]);
       listtree_header = cutElement(listtree_header,lasttwo[1]);
       //printlist(listtree_header);
       
   }     
}    

int findCode(huffmanTree *const header,unsigned char src_byte,char **code){
    huffmanTree *iterator = header;
    while(iterator != NULL){
        if(iterator->ch == src_byte){
           *code = iterator->huffmancode;
           
           return iterator->codelen;
        }   
         iterator = iterator->list_next;
    }    
    return 0;
}    

#define setbit(x,y) x|=(1<<y) //将X的第Y位置1
#define getbit(x,y) (x&(1<<y))>>y        //读取x的第y位 
//由huffman压缩数据
void huffCompress(huffmanTree *const listheader,unsigned char *src,int src_len,unsigned char *dest,int dest_len){
    //扫描源数组，找到相应编码，写入位中
    //一次编码不够8bit记录下来，下次接着写 
    // 
    char *codeaddr;
    int destbitindex = 0;       //总bit索引 
    int destbyteindex = 0;      //byteindex由bitindex计算得来 
    for(int i = 0 ;i < src_len ;i++){
         compresscount++;
         compressprogress = compresscount/(float)src_len;
         
         if(compresscount%500000 == 0){
    
            cout<<"progress:"<<compressprogress * 100<<"%"<<endl;
            
         }    
         int codelen = findCode(listheader,src[i],&codeaddr);
         //先把上次遗留的bit位填满 
         int codebitscount = 0;
         //填写上次空位,从左边高位开始 
         for(int j = 0 ;j < codelen;j++){
             if(codeaddr[codebitscount++] == 1){
                 destbyteindex = destbitindex / 8;
                 int bitoffset = destbitindex % 8;  //离左边的偏移量 
                 setbit(dest[destbyteindex],7 - bitoffset);
                 
             }    
             destbitindex++;
         }    
    }    
}     

//传进huff树，源二进制串，目标串，目标串长度(此即解压后的长度) 
void huffDecompress(huffmanTree *const treeheader,unsigned char *binary_src,int src_len,unsigned char *dest,int dest_len){
    int bitindex = 0;
    int byteindex = 0;
    int destbyteindex = 0;
    huffmanTree *iterator = treeheader;
   // cout<<"数字："; 
    //for(int i = 0 ;i < src_len;i++){
       //int a = binary_src[i];
       //char binbuf[32]; //存储二进制字串的空间
       //printf("%s", itoa(a, binbuf, 2)); //最后一个参数2表示2进制 
    //}   
    //cout<<endl<<"取数：";
    while(true){
       
       if(iterator->isleafnode){
           //查到了叶子节点 
           dest[destbyteindex] = iterator->ch;
           iterator = treeheader; //迭代器归位 
           destbyteindex++;
           if(destbyteindex == dest_len)break;    
       }    
       
       byteindex = bitindex / 8;
       int bitoffset = bitindex % 8; //离左边的偏移量 
       //读取源二进制串的一位，直到找到叶子节点 
       int srcbit = getbit(binary_src[byteindex],7 - bitoffset);
       //cout<<srcbit;
       if(srcbit == 0){
           iterator = iterator->left_child;  //左节点 
       }
       if(srcbit == 1){
           iterator = iterator->right_child;
       }        
       
       bitindex++; 
    }    
}     

//压缩文件
void compressFile(char *srcfilename){
    int srcfilenamelen = strlen(srcfilename);
    char compressname[srcfilenamelen + 15];
    compressname[0] = '\0';
    char suffix[] = ".huffman-YU";
    strcat(compressname,srcfilename);
    strcat(compressname,suffix);
    FILE *srcfile = fopen(srcfilename,"rb+");
    fseek(srcfile,0,SEEK_END);
    int file_len = ftell(srcfile);
    fseek(srcfile,0,SEEK_SET);
    unsigned char * filememory = new unsigned char[file_len];
    fread(filememory,1,file_len,srcfile);
    int statistics[256];
    for(int i = 0 ;i < 256 ;i++){
       statistics[i] = 0;
    }    
    for(int i = 0 ;i < file_len ;i++){
           statistics[filememory[i]]++;
    }    
    
     
    //用统计数据创建huffman树 
    createHuffTree(statistics);
         
    //给叶子节点编码 
    //先把叶子节点取出 
    preOrderTree(listtree_header);
    //cout<<endl<<"leaf:"<<endl;
    //cout<<"listlen:"<<listlength(leaflist_header); 
    //printlist(leaflist_header);
    //设置叶子节点的huffman编码 
    setfuffmanCode(leaflist_header);
    //根据huffman编码压缩数据 
    unsigned char * compress_dest = new unsigned char[compress_len];
    //清零
    for(int i = 0 ;i < compress_len;i++){
           compress_dest[i] = 0;
    }     
    
    huffCompress(leaflist_header,filememory,file_len,compress_dest,compress_len);
    cout<<"compress_len:"<<compress_len<<endl;
    //将压缩后的数据写入文件
    //先写文件名长度，文件名，256个统计数据
    FILE * compress_file = fopen(compressname,"wb+"); 
    fwrite(&srcfilenamelen,sizeof(int),1,compress_file);
    fwrite(srcfilename,sizeof(char),srcfilenamelen,compress_file);
    fwrite(statistics,sizeof(int),256,compress_file);
    //写入压缩数据长度和数据
    fwrite(&compress_len,sizeof(int),1,compress_file);
    fwrite(compress_dest,sizeof(char),compress_len,compress_file);
    
    fclose(srcfile); 
    fclose(compress_file);
    
}     

//解压文件
void decompressFile(char *srcfilename){
    cout<<endl<<"解压："; 
    FILE *srcfile = fopen(srcfilename,"rb+"); 
    //读取文件名
    int filenamelen;
    fread(&filenamelen,sizeof(int),1,srcfile); 
    char *filename = new char[filenamelen + 1];
    fread(filename,sizeof(char),filenamelen,srcfile);
    filename[filenamelen] = '\0';
    //读取统计数据
    int statistics[256];
    int compressdatalen;
    fread(statistics,sizeof(int),256,srcfile);
    fread(&compressdatalen,sizeof(int),1,srcfile);
    unsigned char *compressdata = new unsigned char[compressdatalen];
    fread(compressdata,sizeof(char),compressdatalen,srcfile);
    int decompressdatalen = 0;
    for(int i = 0 ;i < 256; i++){
        decompressdatalen += statistics[i];
    }    
    cout<<"decompressdatalen: "<<decompressdatalen<<endl;
    createHuffTree(statistics); 
    //给叶子节点编码 
    //先把叶子节点取出 
    preOrderTree(listtree_header);
    //设置叶子节点的huffman编码 
    setfuffmanCode(leaflist_header);
    //解压
    unsigned char *decompressdata = new unsigned char[decompressdatalen];
    huffDecompress(listtree_header,compressdata,compressdatalen,decompressdata,decompressdatalen); 
    char attachchars[] = "copy-";
    char copyfilename[100];
    copyfilename[0] = '\0';
    strcat(copyfilename,attachchars);
    strcat(copyfilename,filename);
    cout<<"copyname:"<<copyfilename<<endl;
    FILE *destfile = fopen(copyfilename,"wb+");
    fseek(destfile,0,SEEK_SET);
    fwrite(decompressdata,sizeof(char),decompressdatalen,destfile);
    fclose(srcfile);
    fclose(destfile);
}     

main(){

   //compressFile("iphone.pdf");
   decompressFile("iphone.pdf.huffman-YU");
   
   system("PAUSE");
}
westice
关注
专栏目录
C++ huffman数据压缩算法实现(附源码)
Keivin
12-06 3779
什么是Huffman压缩 Huffman( 哈夫曼 ) 算法在上世纪五十年代初提出来了，它是一种无损压缩方法，在压缩过程中不会丢失信息熵。并且能够证明 Huffman 算法在无损压缩算法中是最优的。 Huffman 原理简单，实现起来也不困难，在如今的主流压缩软件得到了广泛的应用。 相应用程序、重要资料等绝对不同意信息丢失的压缩场合， Huffman 算法是非常好的选择。 怎么实现Huffman压缩 哈夫曼压缩是个无损的压缩算法，一般用来压缩文本和程序文件。哈夫曼压缩属于..
如何用ZipFile.write()压缩打包文件夹
Jean_821的博客
02-11 4047
要用os.walk()遍历文件夹。 这个folder2zip.py程序定义了两个函数： 一个只执行打包压缩的函数， 一个使用时调用的函数，包含执行压缩的函数，同时判断压缩包是否已存在，如果已存在则询问是否继续压缩。 import os from zipfile import ZipFile def backupZip(folder): ...
一个简单的文件压缩程序——在cmd窗口的实现。
LPJLBJ的博客
10-24 623
在C primier plus 13.3章节中，介绍了一个简单压缩程序，代码如下： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define LEN 40 int main(int argc,char *argv[]) { FILE *in,*out; int ch; ...
一个简单的文件压缩程序
weixin_44374594的博客
07-12 324
//reducto.c--把文件压缩成原来的1/3! #include <stdio.h> #include <stdlib.h> //提供exit()的原型 #include <string.h> //提供strncpy()、strcat()的原型 #define LEN 40 int main(int argc, char *argv[]) { FILE *in, *out; //声明两个个指向FILE的指针 int ch; char name
C# 编写基础压缩程序实例
m0_51214251的博客
11-20 246
我的C#第二次实验 一、前言： 本篇开发环境？ 1、操作系统： Windows 10 X64 2、SDK：Visual Studio 2019 二、编写压缩文件以及解压方法： 1、首先引用C#中的ICSharpCode.SharpZipLib.dll类库，方便我们解压缩Zip格式 2、 ...
异步 SOCKET 编程 - 发送和接收数据
everandforever的专栏
01-24 2777
原作者: DREW SIKORA我本想把发送和接收分开作为两部分,但是最后我决定只略微解释一下 FD_READ ,留下更多的时间来说明更复杂的 FD_WRITE , FD_READ 事件非常容易掌握. 当有数据发送过来时, WinSock 会以 FD_READ 事件通知你, 对于每一个 FD_READ 事件, 你需要像下面这样调用 recv() :int bytes_recv = recv
huffman算法---文件压缩
Sunnylunch-blog
10-30 2297
利用huffman编码的思想对文件进行压缩，主要原理是通过huffman编码来重新表示字符，使得出现频率高的字符编码短，出现少的字符编码长。整体下来的话，所需的总的bit位是减少的。但是要注意当大部分字符出现的频率都差不多时，huffman压缩的压缩效率会很低。 一、利用huffman树对文件进行压缩主要分为以下两部分： 压缩： 1、统计字符出现的次数    因为文件的底层
Huffman的应用之文件压缩与解压缩
微风
10-30 4644
文件压缩与解压缩>      最近这段时间一直在学习树的这种数据结构,也接触到了Huffman树以及了解了什仫是Huffman编码,而我们常用的zip压缩也是利用的Huffman编码的特性，那仫是不是可以自己实现一个文件压缩呢？当然可以了.在文件压缩中我实现了Huffman树和建堆Heap的代码，下面开始介绍思路...      1).统计>读取一个文件统计这个文件中字符出现的次数.
用于文件压缩的huffman算法.zip_huff 压缩_huffman_vc huffman 压缩_压缩算法_文件压缩
09-23
在本压缩包中，"用于文件压缩的huffman算法"可能是包含具体实现细节的文档，如源代码、算法描述或步骤详解。"www.pudn.com.txt"可能是一个示例文本文件，用于演示哈夫曼压缩的效果。开发者使用VC++（Visual C++）这...
文本文件压缩【huffman编码实现】
03-06
文本文件压缩是信息处理中的一个重要领域，特别是在大数据和存储有限的场景下，高效的数据压缩技术显得尤为关键。Huffman编码是一种基于频率的无损数据压缩方法，由David A. Huffman在1952年提出，它是数据结构课程...
huffman java_Huffman 压缩和解压缩java实现
weixin_32790659的博客
02-12 202
for(int i=0;i//w1 : the first min weight w2: the second min weight//i1 : the first min weight index, i2:　the second min weight indexint w1 = MAX_VALUE, w2=MAX_VALUE;int i1 = 0, i2 = 0;// find the two ...
文件压缩解压程序(qt5.5版本可用)
02-11
本项目涉及的是一个基于Qt5.5版本的文件压缩解压程序，该程序带有用户界面和交互按钮，方便用户操作。值得注意的是，开发者在开发过程中遇到了不同Qt版本之间压缩库DLL不兼容的问题，这表明不同版本的Qt框架可能对库...
数据结构-树（基础，分类，遍历）
nice66660的博客
09-15 1263
在计算机科学中，树是一种常用的非线性数据结构，用于表示具有层次关系的数据。与线性数据结构（如数组和链表）不同，树结构以节点（Nodes）和边（Edges）组成，通过根节点（Root Node）进行组织。每个节点可以有零个或多个子节点，形成一系列层级结构。根节点（Root）：树的最上层节点，没有父节点。节点（Node）：树中的基本单元，包含数据和指向子节点的引用。子节点（Child）：直接连接到某一节点的节点。父节点（Parent）：直接连接到子节点的节点。叶节点（Leaf）：没有子节点的节点。
数据结构之线性表（python）
最新发布
huaz_md的博客
09-16 748
线性表零个或多个数据元素的有限序列在逻辑结构上具有线性关系。将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表线性表元素的个数nn>=0）定义为线性表的长度，当n=0时，称为空表。在较复杂的线性表中，一个数据元素可以有若干个数据项组成。线性表又可以分为顺序表顺序存储结构）和链表链式存储结构。
【数据结构-一维差分】力扣1893. 检查是否区域内所有整数都被覆盖
sjsjs11的博客
09-12 528
首先因为是差分的办法，所以i开始必须在ranges中最小的range[0]及其左边开始，但是由于可能会出现left在最小range[0]的左边，从而在遍历left到最小range[0]的时候满足了i>left而且s这时候又为0，会返回false。输入：ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5。输入：ranges = [[1,10],[10,20]], left = 21, right = 21。解释：21 没有被任何一个区间覆盖。
2_foc闭环调试_ADC电流采样与滤波及pid数据结构
Pou光明的博客
09-11 628
1、ADC电流采样上次添加了编码器获取电角度的程序，将之前开环控制的角度进行了替换，这次再将电流采样添加进来，之后就可以利用这样一个有反馈的系统进行电流环PI控制器参数调试。 之前写过ADC＋DMA电流采样的stm32库函数程序，现在来看还是有很大缺陷的：首先当电机没有转动时，ADC采样已经有了一个数值，即是一个偏置，需要后面将其减去，这块采回来的电流理论上是一个正弦波数值。另外需要将...
【数据结构-一维差分】力扣1854. 人口最多的年份
sjsjs11的博客
09-12 346
在使用差分的时候要注意的是death的那一年，就不算入人口，这和覆盖类的差分不一样，覆盖类差分需要。然后我们定义一个res来记录最多人口的年份，maxNum来计入最大人口的数量，然后去遍历每一年的人口，最后返回res+offset就是人口最多的年份。给你一个二维整数数组 logs ，其中每个 logs[i] = [birthi, deathi] 表示第 i 个人的出生和死亡年份。输入：logs = [[1950,1961],[1960,1971],[1970,1981]]返回 人口最多 且 最早 的年份。
嵌入式初学-C语言-数据结构--七
MaBaB的博客
09-12 1071
根指针：指向根节点的指针变量节点：数据域 (存储的实际数据)指针域 (左，右指针)
数据压缩技术详解：从Huffman到JPEG应用与历史
包括电报、传真通信、存储优化（如压缩池和压缩扇区）、文件系统（如GIF/TIFF/JPEG）、音频和视频文件（如MP3/MPEG）、数据库和数据库索引（B+树、TAR/ZIP）、密码学中的数据混淆，以及编程语言（JAVA）和程序设计中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值