Linux下实现Huffman编码压缩算法

最新推荐文章于 2022-07-10 10:21:00 发布
最新推荐文章于 2022-07-10 10:21:00 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： Linux C 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunrier/article/details/7728488
版权
C 同时被 3 个专栏收录
57 篇文章 0 订阅
订阅专栏
Linux
48 篇文章 0 订阅
订阅专栏
算法
3 篇文章 0 订阅
订阅专栏

 

//stack.h

/*************************************************************
    FileName : stack.h 
    FileFunc : 定义栈头文件  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:33:48 
    Descp    : Linux下栈头文件 
*************************************************************/
#ifndef   __STACK_H__
#define   __STACK_H__

#ifdef __cplusplus
extern "C" {
#endif

#include "tree.h"

#define STACK_SIZE 128
#define STACK_INCREMENT_SIZE 128

typedef pTree ElemType;

typedef struct stack
{
	ElemType *bottom;
	int top;
	int size;
}sStack,*pStack;

void init_stack(pStack *p);
int isEmpty(pStack p);
int isFull(pStack p);
int push(pStack,ElemType e);
int pop(pStack p,ElemType *e);
int getTop(pStack p,ElemType *e);

#ifdef __cplusplus
}
#endif

#endif


 

 

//stack.c

/*************************************************************
    FileName : stack.c 
    FileFunc : 定义实现栈函数 
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:33:29 
    Descp    : Linux下实现栈函数
*************************************************************/
#include <stdlib.h>
#include "stack.h"

/*栈先进后出*/
void init_stack(pStack *p)
{
	*p = malloc(sizeof(sStack));
	(*p)->bottom = malloc(sizeof(ElemType)*STACK_SIZE);
	(*p)->top = -1;
	(*p)->size = STACK_SIZE;
}

/*判断栈是否为空*/
int isEmpty(pStack p)
{
	if( -1==p->top )
		return 1;

	return 0;

}

/*判断栈是否已满*/
int isFull(pStack p)
{
	if( (p->size-1)==p->top )
		return 1;
		
	return 0;
}

/*入栈*/
int push(pStack p,ElemType e)
{
	if( isFull(p) )
	{
		p->bottom = realloc(p->bottom,(p->size+STACK_INCREMENT_SIZE)*sizeof(ElemType));
		p->size += STACK_INCREMENT_SIZE;
	}
	
	p->top++;
	p->bottom[p->top] = e;
	
	return 1;
}

/*出栈*/
int pop(pStack p,ElemType *e)
{
	if(isEmpty(p))
	{
		return 0;
	}

	*e = p->bottom[p->top];
	p->top--;
	
	return 1;
}

/*取栈顶数据*/
int getTop(pStack p,ElemType *e)
{
	if( isEmpty(p) )
		return -1;
		
	*e = p->bottom[p->top];

	return 1;
}


 

//queue.h

/*************************************************************
    FileName : queue.h 
    FileFunc : 定义队列头文件  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:51:11 
    Descp    : Linux下队列头文件 
*************************************************************/
#ifndef   __QUEUE_H__
#define   __QUEUE_H__

#ifdef __cplusplus
extern "C" {
#endif

#include "tree.h"

typedef pTree QueueElem;

typedef struct queue
{
	QueueElem data;
	struct queue *next;
}sQueue, *pQueue;

void init_queue(pQueue *p, QueueElem data);
int push_queue(pQueue pq, QueueElem data);
int pop_queue(pQueue pq, QueueElem *data);


#ifdef __cplusplus
}
#endif

#endif


 

//queue.c

/*************************************************************
    FileName : queue.c 
    FileFunc : 定义实现队列函数  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:51:14 
    Descp    : Linux下实现队列函数
*************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

/*队列先进先出*/
void init_queue(pQueue *p, QueueElem data)
{
	*p = malloc(sizeof(sQueue));
	(*p)->data = data;
	(*p)->next = NULL;
}

/*进队列,进来的数据放入队列最后*/
int push_queue(pQueue pq, QueueElem ptree)
{
	pQueue ptrav = pq, pnew;
	if ( NULL==pq )
	{
		return 0;
	}
	while ( NULL!=ptrav->next )
	{
		ptrav = ptrav->next;
	}
	
	init_queue(&pnew, ptree);
	ptrav->next = pnew;
	
	return 1;
}

/*出队列,把队列中第一个数据出队列*/
int pop_queue(pQueue pq, QueueElem *data)
{
	pQueue pdel;
	
	if ( pq == NULL )
	{
		return -1;
	}
	
	if ( pq->next == NULL )
	{
		return 0;
	}
	pdel = pq->next;
	*data = pdel->data;
	pq->next = pdel->next;
	free(pdel);
	
	return 1;
}


 

 

//tree.h

/*************************************************************
    FileName : tree.h 
    FileFunc : 定义二叉树头文件  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:58:03 
    Descp    : Linux下二叉树头文件 
*************************************************************/
#ifndef   __TREE_H__
#define   __TREE_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>

typedef unsigned char etype;
typedef int type;

typedef struct TreeNode
{
	etype data;
	type count;
	struct TreeNode *next;
	struct TreeNode *left;
	struct TreeNode *right;
}Tree,*pTree;

void Init_TreeNode(pTree *p);
void Init_eTreeNode(pTree *p,etype data);
int Read_File(pTree proot,FILE *pr,FILE *pw);
pTree Get_Frequency(pTree proot);
void Huffman(pTree *proot);
void Read_Huffman(pTree proot,int n,FILE *pr,FILE *pw);
void Create_Huffman(pTree proot,int ch,FILE *pr);
void ReHuffman(pTree proot,FILE *pr,FILE *pw,int count,int Num_Byte);

#ifdef __cplusplus
}
#endif

#endif


 

 

//tree.c

/*************************************************************
    FileName : tree.c 
    FileFunc : 定义实现二叉树函数  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 09:58:00 
    Descp    : Linux下实现二叉树函数
*************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "tree.h"
#include "stack.h"
#include "queue.h"

/*初始化树的结点*/
void Init_TreeNode(pTree *p)
{
	*p=malloc(sizeof(Tree));
	(*p)->data = 0;
	(*p)->count = 0;
	(*p)->left = NULL;
	(*p)->right = NULL;
	(*p)->next = NULL;
}

/*初始化树的结点数据*/
void Init_eTreeNode(pTree *p,etype data)
{
	*p = malloc(sizeof(Tree));
	(*p)->data = data;
	(*p)->count = 1;;
	(*p)->left = NULL;
	(*p)->right = NULL;
	(*p)->next = NULL;
}

/*取原文件数据构造树型链表*/
int Read_File(pTree proot,FILE *pr,FILE *pw)
{
	pTree p,pnew;
	unsigned char ch;
	
	if( NULL==proot )
		return 0;
		
	/*静态统计模型*/
	/*统计原始数据中各字符出现的频率(即个数)*/
	while( fread(&ch,sizeof(unsigned char),1,pr)>0 )
	{
		printf("%c",ch);
		
		for(p=proot; p->next!=NULL; p=p->next)
		{
			if(p->next->data==ch)
			{
				(p->next->count)++;
				break;
			}
		}	
			
		if( ( NULL==p->next) && (ch!=p->data) )
		{
			Init_eTreeNode(&pnew,ch);
			p->next = pnew;
		}
	}

	printf("\n");
	int total = 0,num = 0;
	
	/*统计原始数据中不同字符出现的个数以及所有字符出现的总的次数*/
	for(p=proot->next; p!=NULL; p=p->next)
	{
		fwrite(&p->data,sizeof(char),1,pw);		
		fwrite(&p->count,sizeof(int),1,pw);		
		printf("%c:%d\n",p->data,p->count);
		total += p->count;
		num++;
	}
	printf("total:%d num:%d\n",total,num);
	return num;
}

/*从树型链表中找出字符频率出现最小的结点*/
pTree Get_Frequency(pTree proot)
{
	if( NULL==proot->next ) 
		return NULL;
		
	pTree p,ps = proot,min = proot->next,prev;
	for(prev=proot; prev->next!=NULL; prev=prev->next)
	{
		p = prev->next;
		if( p->count<min->count )
		{
			min = p;
			ps = prev;
		}
	}

	ps->next = min->next;
	printf("huffman:%d",min->count);
	return min;	
}

/*构造最小二叉树*/
void Huffman(pTree *proot)
{
	pTree min1,min2;
	pTree pnew,p;

	while( ((min1=Get_Frequency(*proot))!=NULL) && ((min2=Get_Frequency(*proot))!=NULL) )
	{	
		Init_TreeNode(&pnew);
		puts("*");
		pnew->left = min1;
		pnew->right = min2;
		pnew->count = min1->count+min2->count;
		min1->next = pnew;
		min2->next = pnew;
		p = (*proot)->next;
		(*proot)->next = pnew;
		pnew->next = p;
	}

	free(*proot);
	*proot = min1;
	puts("----");
}

/*对二叉树进行编码,得到各个字符的编码格式写到压缩后的文件中*/
void Read_Huffman(pTree proot,int n,FILE *pr,FILE *pw)
{
	unsigned char bigcode = 0;
	pTree pnew,pp,pc;
	Init_eTreeNode(&pnew,0);
	
	pStack ps;
	init_stack(&ps);
	
	pQueue p;
	init_queue(&p,NULL);

	int count = 0,Num_Byte = 1;
	unsigned char ch;
	
	while( fread(&ch,sizeof(char),1,pr)>0 )
	{
		push_queue(p,proot);
		
		while( pop_queue(p,&pnew) )
		{
			if( NULL==pnew->left )
			{
				if( ch==pnew->data )/*找到队列中的匹配字符*/
				{
					/*printf("ch = %c \n",ch);*/
					while( NULL!=pnew )/*父结点全部压栈,以便编码*/
					{
						push(ps,pnew);
						pnew=pnew->next;
					}
					
					pop(ps,&pp);
					while( pop(ps,&pc) )
					{
						if( 8==count )
						{	
							fwrite(&bigcode,sizeof(char),1,pw);
							count = 0;
							bigcode = 0;Num_Byte++;		
						}
						if( pp->left==pc )/*判断是左结点还是右结点,左结点上为0,右结点上为1*/
						{
								bigcode = (bigcode<<1)+0;
								count++;
						}
						else
						{
								bigcode = (bigcode<<1)+1;
								count++;			
						}

						pp = pc;
					}
					
					while( pop_queue(p,&pnew) );/*其他字符全部出队列*/

				}
			}
			else 
			{
				push_queue(p,pnew->right);
				push_queue(p,pnew->left);
			}
		}
	}
	
	bigcode = bigcode<<(8-count);
	fwrite(&bigcode,sizeof(char),1,pw);
	printf("bigcode=%d\n",bigcode);
	
	int info0 = n;
	int info1 = count;
	int info2 = Num_Byte;
	fwrite(&info0,sizeof(int),1,pw);
	fwrite(&info1,sizeof(int),1,pw);
	fwrite(&info2,sizeof(int),1,pw);
}

/*取压缩文件的数据构造树型链表*/
void Create_Huffman(pTree proot,int ch,FILE *pr)
{

	if( NULL==proot )
		return ;
		
	etype data;type count;

	printf("ch=%d\n",ch);
	pTree p = proot,pnew;
	
	while( ch )
	{
		fread(&data,sizeof(etype),1,pr);
		fread(&count,sizeof(type),1,pr);
	
		Init_eTreeNode(&pnew,data);
		pnew->data = data;
		pnew->count = count;
		p->next = pnew;
		p = pnew;
		ch--;
	}
	
	int total = 0,num = 0;
	for(p=proot->next; p!=NULL; p=p->next)
	{
		total += p->count;
		num++;
	}
	
	printf("total:%d num:%d\n",total,num);
	
}

/*取压缩的文件二叉树编码,对其解压数据*/
void ReHuffman(pTree proot,FILE *pr,FILE *pw,int count ,int Num_Byte)
{
	pTree p = proot;
	
	unsigned char ch,chcpy[8];
	int n;
	while( --Num_Byte&&fread(&ch,sizeof(unsigned char),1,pr)>0 )
	{
		printf("0x%x\n",ch);
		chcpy[0] = ch&128;
		chcpy[1] = ch&64;
		chcpy[2] = ch&32;
		chcpy[3] = ch&16;
		chcpy[4] = ch&8;
		chcpy[5] = ch&4;
		chcpy[6] = ch&2;
		chcpy[7] = ch&1;
		
		for(n=0; n<8; n++)	
			printf("%d--",chcpy[n]);
			
		n = 0;
		while( n<8 )
		{
			if( NULL==p->left )
			{
				printf("\n%d\n",n);
				printf("%d\n",chcpy[n]);
				printf("%c\n",p->data);
				fwrite(&p->data,sizeof(unsigned char ),1,pw);
				p = proot;
				continue;
			}
			
			if( chcpy[n] )
			{
				p = p->right;
			}
			else 
			{
				p = p->left;
			}
			
			n++;
		}
	}

	fread(&ch,sizeof(unsigned char),1,pr);
	chcpy[0] = ch&128;
	chcpy[1] = ch&64;
	chcpy[2] = ch&32;
	chcpy[3] = ch&16;
	chcpy[4] = ch&8;
	chcpy[5] = ch&4;
	chcpy[6] = ch&2;
	chcpy[7] = ch&1;
	
	for(n=0; n<8; n++)	
		printf("%d--",chcpy[n]);
	
	n = 0;
	while( n<count )
	{
		if( NULL==p->left )
		{
			printf("%c:\n",p->data);
			fwrite(&p->data,sizeof(char),1,pw);
			p = proot;
			continue;
		}
			
		if(chcpy[n])
		{
			p = p->right;
		}
		else 
		{
			p = p->left;
		}
		n++;
	}
	
}


 

 

//demo.c

/*************************************************************
    FileName : demo.c 
    FileFunc : 定义实现Huffman算法  
    Version  : V0.1  
    Author   : Sunrier  
    Date     : 2012-07-09 10:52:17 
    Descp    : Linux下实现Huffman算法压缩/解压文件 
*************************************************************/
#include <stdio.h>
#include "tree.h"
#include "queue.h"

int main(int argc,char *argv[])
{
	FILE *pr,*pw;
	pTree proot;
	
	Init_TreeNode(&proot);
	
	int num = 0;
	
	if( argc<4 )
	{
		fprintf(stderr,"Usage: \n ");
		fprintf(stderr," Compress : %s c sourcefile destfile \n", argv[0]);
		fprintf(stderr," Decompress : %s d sourcefile destfile \n", argv[0]);
		return 1;
	}
	
	if( 'c'==*argv[1] )/*表示压缩文件*/
	{
		pr = fopen(argv[2],"r");
		if( NULL==pr )
		{
			perror("Read file failed !\n");
			return -1;
		}
		
		pw = fopen(argv[3],"w");
		if( NULL==pw )
		{
			perror("Write file failed !\n");
			return 1;
		}
		
		num = Read_File(proot,pr,pw);
		Huffman(&proot);
		fseek(pr,0,SEEK_SET);
		Read_Huffman(proot,num,pr,pw);
	}
	else if('d'==*argv[1])/*表示解压文件*/
	{
		int count,Num_Byte,ch;
		
		pr = fopen(argv[2],"r");
		if( NULL==pr )
		{
			perror("Read file failed !\n");
			return 1;
		}
		
		fseek(pr,-12,SEEK_END);
		fread(&ch,sizeof(int),1,pr);
		fread(&count,sizeof(int),1,pr);
		fread(&Num_Byte,sizeof(int),1,pr);
		printf("%d/%d/%d\n",ch,count,Num_Byte);
		
		fseek(pr,0,SEEK_SET);
		Create_Huffman(proot,ch,pr);
		Huffman(&proot);
		fseek(pr,(sizeof(int)+sizeof(char))*ch,SEEK_SET);
		pw = fopen(argv[3],"w");
		if( NULL==pw )
		{
			perror("Write file failed !\n");
			return 1;
		}
		
		ReHuffman(proot,pr,pw,count,Num_Byte);
	}
	else
	{
		fprintf(stderr,"Usage: \n ");
		fprintf(stderr," Compress : %s c sourcefile destfile \n", argv[0]);
		fprintf(stderr," Decompress : %s d sourcefile destfile \n", argv[0]);
		return 1;
	}

	return 0;
}


 

 

//makefile

#makefile  
OBJS = demo    
all:$(OBJS)    
#CFLAGS = -O -w -ansi       
#CFLAGS = -O -Wall -ansi 
CFLAGS = -g -Wall -ansi       
CC = gcc $(CFLAGS)  
#SRCS = *.c
SRCS = demo.c tree.c stack.c queue.c

demo:$(SRCS)
	@$(CC) -o $@ $? 
clean	:
	@ls | grep -v ^makefile$$ | grep -v [.]c$$ | grep -v [.]h$$ | grep -v [.]sql$$ | grep -v [.]sh$$ | xargs rm -rf
#makefile


 

[Sunrier@localhost Huffman]$ ls
demo.c  makefile  queue.c  queue.h  stack.c  stack.h  tree.c  tree.h
[Sunrier@localhost Huffman]$ make
[Sunrier@localhost Huffman]$ ls
demo  demo.c  makefile  queue.c  queue.h  stack.c  stack.h  tree.c  tree.h
[Sunrier@localhost Huffman]$ ./demo c demo.c 1
.................................
.................................
.................................
[Sunrier@localhost Huffman]$ ls
1  demo  demo.c  makefile  queue.c  queue.h  stack.c  stack.h  tree.c  tree.h
[Sunrier@localhost Huffman]$
[Sunrier@localhost Huffman]$ ./demo d 1 1.c
.................................
.................................
.................................
[Sunrier@localhost Huffman]$ ls
1  1.c  demo  demo.c  makefile  queue.c  queue.h  stack.c  stack.h  tree.c  tree.h
[Sunrier@localhost Huffman]$

 

注:此程序功能对于大文件的压缩和解压还无法实现

 

 

 

sunrier
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言哈夫曼编码与STM32哈夫曼编码源码
07-16
资源内是哈夫曼编码的C语言源码以及STM32端的移植代码，C语言源码可直接运行main中的文件查看输出结果，STM32端工程可使用Keil5MDK打开，运行结果可使用串口助手查看。
STM32中，用c语言写一个哈夫曼树压缩字符串函数
weixin_42593130的博客
02-16 183
好的，以下是一个用C语言编写的基本的哈夫曼树压缩字符串函数： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> // 哈夫曼树节点结构体 struct HuffmanNode { char data; int freq; struct HuffmanNode *l...
linux下基于哈夫曼树的具有压缩功能的代码（c语言）
12-29
linux下基于哈夫曼树的具有压缩功能的代码（c语言） ，
Linux c++实现哈夫曼编码实现文件压缩器与解压器
01-07
程序在Linux下能实现对任意文本文件的压缩与解压，包括中文字符，英文字符等，最终压缩占空间大小比是 压缩文件：源文件约为1:2。
Huffman 编码压缩算法
08-01
Huffman 编码压缩算法，c++代码。实现数据压缩。
Huffman 编码图像无损压缩和解压缩 Python示例代码 哈夫曼编码
最新发布
08-13
本程序实现了利用 Huffman 编码对图像进行无损压缩和解压缩。Huffman 编码是一种基于字符出现频率构建相应前缀码的无损数据压缩算法。 使用方法： 1. 需要安装 OpenCV 和 Numpy 库： pip install opencv-python ...
详解Huffman编码算法之Java实现
08-31
Huffman编码是一种编码方式,常用于无损压缩。本文只介绍用Java语言来实现该编码方式的算法和数据结构。有兴趣的可以了解一下。
huffman编码实现压缩与解压文件
02-20
使用java实现的采用Huffman编码来实现文件的压缩与解压，亲自测试，好使！
huffmanbianma.rar_huffman_压缩算法
09-20
huffman压缩算法，c语言编写。可下下来参考
带你手把手实现Huffman压缩
weixin_45897952的博客
07-10 2303
文件压缩是我们日常所用运最广泛的应用了，但是你是否好奇它是如何实现文件压缩，又如何解压。这篇文章将带你撩开文件压缩的神秘面纱，带你实现一个基于huffman编码最简单的文件压缩项目。看到这里有Huffman编码不要怕，Huffman编码其实很简单。...
huffman编码与解码
g_m_n的博客
04-23 1626
一.相关知识及公式 1.信息熵 熵是信息的度量单位，香农将信息定义为“用来消除不确定性的东西”。 信息熵用H表示，单位是比特/符号，对任意一个随机变量X，熵定义如下： 变量的不确定性越大，信息熵越大，即了解它需要的信息越多 2.huffman编码：一种无失真的变长编码方式（VLC） 基于信源的概率统计模型，大概率的信源符号编短码，小概率的信源符号编长码。 使用二叉树结构，
linux下c/c++实例之十七哈夫曼编码译码实现
乌托邦
05-31 2306
一、简介 大学期间用vc++开发的哈夫曼编码和译码的功能，完成发送端对传送数据的编码和接收端对传送来的数据的译码。哈夫曼编码/译码实现主要有四个功能模板：一是创建哈夫曼树，从终端输入字符集大小为n，即n个字符和n个权值，建立哈夫曼树；二是输出哈夫曼树，将建立的哈夫曼树用某种树的存储方式存储后输出，即字符与编码的一一对应关系；三是哈夫曼编码，利用已建立好的哈夫曼树对输入的原文进...
哈夫曼树（Huffman-Tree）的构造及应用
私は Mocha!!
07-02 6857
　　本文以学习笔记的性质谈一种哈夫曼树较为严谨的贪心做法，哈夫曼树的应用将在往后补上。 　 　　有这样一棵k叉树，它的叶子节点有权值，第i个叶子节点权值为wi(wi&amp;amp;gt;0)wi(wi&amp;amp;gt;0)w_i(w_i&amp;gt;0)，他的深度为lilil_i，要求最小化∑wi∗li∑wi∗li\sum w_i*l_i，这样问题的解称为k叉哈夫曼树。 　　为了最小化∑wi∗li∑wi∗li\sum w_...
哈夫曼数与哈夫曼编码
YE3485365的博客
04-20 181
#include<stdio.h> #include <iostream> using namespace std; struct HuffNode //哈夫曼树结点结构 { int weight; //权值 int parent; //父结点 int lchild; ...
Linux下学习DB2命令的笔记
热门推荐
sunrier的专栏
08-06 4万+
本笔记接在上一篇 > http://blog.csdn.net/sunrier/article/details/7826233,学习过程中使用下载的官网DB2数据库(免费版本)测试的,由于工作中DB2是用在项目中的,而且是收费的数据库,故我只在项目编程中使用它(即公司的DB2数据库收费版本),没用来作为自己测试用。嘿嘿,所以下面的大部分操作主要来自下载的官网DB2数据库(免费版本)。
Linux下“ ＞/dev/null 2＞&1 “相关知识说明
sunrier的专栏
07-20 4万+
在学习Linux的过程中,常会看到一些终端命令或者程序中有">/dev/null 2>&1 "出现,由于已经遇到了好几次了,为了理解清楚,不妨花点时间百度或者google一下相关的知识。 0:表示键盘输入(stdin) 1:表示标准输出(stdout),系统默认是1 2:表示错误输出(stderr) command >/dev/null 2>&1 & == command
Linux下安装DB2数据库步骤
sunrier的专栏
08-03 3万+
前言:   最近有些项目在Linux下使用的是IBM的DB2数据库,感觉没MySQL那样容易了解深入,可能是DB2数据库更倾向于商业化,没MySQL那样开源,相关DB2的资源网上没MySQL那样普及,至于在学习DB2过程中没学MySQL那样顺畅.   下面简单记录下学习笔记,我所使用的Linux系统是RedHat企业版本(Red Hat Enterprise Linux 5),此为自己安装在
用python实现Huffman编码压缩和解压缩文件
04-09
好的，关于Huffman编码压缩和解压缩文件的实现，我们可以使用Python中的heapq、collections、struct等库来实现。具体来说，我们可以首先读取待压缩的文件，统计文件中每个字符出现的次数，然后使用heapq库来进行编码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值