LZW编解码

最新推荐文章于 2022-07-08 18:15:57 发布
最新推荐文章于 2022-07-08 18:15:57 发布
阅读量770 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43310997/article/details/105655181
版权

LZW简介

Lempel-Ziv-Welch Encoding ，简称 LZW 的压缩算法。LZW压缩算法的基本原理：提取原始文本文件数据中的不同字符，基于这些字符创建一个编译表，然后用编译表中的字符的索引来替代原始文本文件数据中的相应字符，减少原始数据大小。字符串和编码的对应关系是在压缩过程中动态生成的，并且隐含在压缩数据中，解压的时候根据表来进行恢复，算是一种无损压缩。

LZW编码流程

LZW解码流程

数据结构分析

字典树

struct {                                       //定义词典的结构
	int suffix;                            //尾缀字符
	int parent, firstchild, nextsibling;   //母节点，第一个孩子节点，下一个兄弟节点
} dictionary[MAX_CODE+1];

 

主要功能模块

void InitDictionary( void){                       //初始化字典，即将256个字符及其对应编码（0-255）输入到字典
	int i;

	for( i=0; i<256; i++){
		dictionary[i].suffix = i;
		dictionary[i].parent = -1;       
		dictionary[i].firstchild = -1;
		dictionary[i].nextsibling = i+1; //后一个就是当前节点的兄弟节点
	}
	dictionary[255].nextsibling = -1;        //最后一个没有兄弟节点
	next_code = 256;                         //下一个suffix是256
}
/*
 * Input: string represented by string_code in dictionary,
 * Output: the index of character+string in the dictionary
 * 		index = -1 if not found
 */
int InDictionary( int character, int string_code){                 //查找词典中是否有字符串
	int sibling;                                               
	if( 0>string_code) return character;                       //如果前面无前缀，返回当前字符   
	sibling = dictionary[string_code].firstchild;              //前缀为string_code的第一个孩子节点
	while( -1<sibling){        
		if( character == dictionary[sibling].suffix) return sibling; //如果当前child的尾缀和字符character相同，返回srting+character
		sibling = dictionary[sibling].nextsibling;                   //否则查找当前child的下一个兄弟节点
	}
	return -1;
}

 

void AddToDictionary( int character, int string_code){      //将新串加入字典
	int firstsibling, nextsibling;
	if( 0>string_code) return;
	dictionary[next_code].suffix = character;
	dictionary[next_code].parent = string_code;
	dictionary[next_code].nextsibling = -1;
	dictionary[next_code].firstchild = -1;
	firstsibling = dictionary[string_code].firstchild;
	if( -1<firstsibling){	                                      // the parent has child
		nextsibling = firstsibling;
		while( -1<dictionary[nextsibling].nextsibling ) 
			nextsibling = dictionary[nextsibling].nextsibling;
		dictionary[nextsibling].nextsibling = next_code;
	}else{                                                        // no child before, modify it to be the first
		dictionary[string_code].firstchild = next_code;
	}
	next_code ++;
}

主要代码

main函数 

int main( int argc, char **argv){
	FILE *fp;                      //输入的文件
	BITFILE *bf;                   //输出的文件

	//调试需要4个输入参数，分别是argv[0]:提示使用方法（编解码标识符=输入文件+输出文件），argv[1]：'E'/'D'（选择编码还是解码），argv[2]：输入文件，argv[3]：输出文件
	if( 4>argc){
		fprintf( stdout, "usage: \n%s <o> <ifile> <ofile>\n", argv[0]);
		fprintf( stdout, "\t<o>: E or D reffers encode or decode\n");
		fprintf( stdout, "\t<ifile>: input file name\n");
		fprintf( stdout, "\t<ofile>: output file name\n");
		return -1;
	}
	if( 'E' == argv[1][0]){                                 // do encoding
		fp = fopen( argv[2], "rb");                     //以二进制打开输入文件
		bf = OpenBitFileOutput( argv[3]);               //打开输出文件
		if( NULL!=fp && NULL!=bf){
			LZWEncode( fp, bf);                     //对输入文件进行编码
			fclose( fp);                            //关闭输入文件
			CloseBitFileOutput( bf);                //关闭输出文件
			fprintf( stdout, "encoding done\n");    //提示编码工作完成
		}
	}else if( 'D' == argv[1][0]){	                        // do decoding
		bf = OpenBitFileInput( argv[2]);
		fp = fopen( argv[3], "wb");
		if( NULL!=fp && NULL!=bf){
			LZWDecode( bf, fp);                     //对输入文件进行解码
			fclose( fp);
			CloseBitFileInput( bf);
			fprintf( stdout, "decoding done\n");    //提示解码工作完成
		}
	}else{	                                                // otherwise
		fprintf( stderr, "not supported operation\n");
	}
	return 0;
}

 

LZWEncode函数

void LZWEncode( FILE *fp, BITFILE *bf){
	int character;                           //下一个字符
	int string_code;                         //当前前缀（串）的编码
	int index;                               
	unsigned long file_length;               //文件长度

	fseek( fp, 0, SEEK_END);                 //把文件指针移到文件尾
	file_length = ftell( fp);                //读出文件长度
	fseek( fp, 0, SEEK_SET);                 //把文件指针移到文件头
	BitsOutput( bf, file_length, 4*8);       //将需要编码的文件长度写入输出文件
	InitDictionary();                        //初始化字典
	string_code = -1;                        //将前缀编码定义为空
	while( EOF!=(character=fgetc( fp))){
		index = InDictionary( character, string_code);     //判断string+character(即P+C)是否在字典中
		if( 0<=index){	                                   // string+character在字典中，此时新的string=string+character(即P<-P+C)
			string_code = index;
		}else{	                                           // string+character不在字典中，此时输出string_code
			output( bf, string_code);
			if( MAX_CODE > next_code){	           // free space in dictionary
			AddToDictionary( character, string_code);  // add string+character to dictionary(即P+C->字典)
			}
			string_code = character;                   //将string_code置为character(即P<-C)
		}
	}
	output( bf, string_code);
}

LZWDecode函数 

void LZWDecode( BITFILE *bf, FILE *fp){
	int character;                          //即C,str(PW)的第一个字符
	int new_code, last_code;                //即CW,PW
	int phrase_length;                      //字符串长度
	unsigned long file_length;              //文件长度

	file_length = BitsInput( bf, 4*8);      //读出文件长度
	if( -1 == file_length) file_length = 0;
	InitDictionary();                       //字典初始化
	last_code = -1;
	while (0 < file_length) {
		new_code = input(bf);           
		if (new_code >= next_code) {                          //在字词典中
			d_stack[0] = character;
			phrase_length = DecodeString(1, last_code);
		}
		else {                                                //不在字典中
			phrase_length = DecodeString(0, new_code);
		}
		character = d_stack[phrase_length - 1];
		while (0 < phrase_length) {
			phrase_length--;
			fputc(d_stack[phrase_length], fp);
			file_length--;
		}
		if (MAX_CODE > next_code) {                           //输出解码码字到字典中   
			AddToDictionary(character, last_code);        //即P+C->字典
		}
		last_code = new_code;                                 //即PW<-CW
	}
}

实验结果

1.调试过程

 

2.编解码结果

完整代码 

bitio.h 

/*
 * Declaration for bitwise IO
 *
 * vim: ts=4 sw=4 cindent
 */
#ifndef __BITIO__
#define __BITIO__

#include <stdio.h>

typedef struct{
	FILE *fp;
	unsigned char mask;
	int rack;
}BITFILE;

BITFILE *OpenBitFileInput( char *filename);
BITFILE *OpenBitFileOutput( char *filename);
void CloseBitFileInput( BITFILE *bf);
void CloseBitFileOutput( BITFILE *bf);
int BitInput( BITFILE *bf);
unsigned long BitsInput( BITFILE *bf, int count);
void BitOutput( BITFILE *bf, int bit);
void BitsOutput( BITFILE *bf, unsigned long code, int count);
#endif	// __BITIO__

 bitio.c

 

/*
 * Definitions for bitwise IO
 *
 * vim: ts=4 sw=4 cindent
 */
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include "bitio.h"
BITFILE *OpenBitFileInput( char *filename){
	BITFILE *bf;
	bf = (BITFILE *)malloc( sizeof(BITFILE));
	if( NULL == bf) return NULL;
	if( NULL == filename)	bf->fp = stdin;
	else bf->fp = fopen( filename, "rb");
	if( NULL == bf->fp) return NULL;
	bf->mask = 0x80;
	bf->rack = 0;
	return bf;
}

BITFILE *OpenBitFileOutput( char *filename){
	BITFILE *bf;
	bf = (BITFILE *)malloc( sizeof(BITFILE));
	if( NULL == bf) return NULL;
	if( NULL == filename)	bf->fp = stdout;
	else bf->fp = fopen( filename, "wb");
	if( NULL == bf->fp) return NULL;
	bf->mask = 0x80;
	bf->rack = 0;
	return bf;
}

void CloseBitFileInput( BITFILE *bf){
	fclose( bf->fp);
	free( bf);
}

void CloseBitFileOutput( BITFILE *bf){
	// Output the remaining bits
	if( 0x80 != bf->mask) fputc( bf->rack, bf->fp);
	fclose( bf->fp);
	free( bf);
}

int BitInput( BITFILE *bf){
	int value;

	if( 0x80 == bf->mask){
		bf->rack = fgetc( bf->fp);
		if( EOF == bf->rack){
			fprintf(stderr, "Read after the end of file reached\n");
			exit( -1);
		}
	}
	value = bf->mask & bf->rack;
	bf->mask >>= 1;
	if( 0==bf->mask) bf->mask = 0x80;
	return( (0==value)?0:1);
}

unsigned long BitsInput( BITFILE *bf, int count){
	unsigned long mask;
	unsigned long value;
	mask = 1L << (count-1);
	value = 0L;
	while( 0!=mask){
		if( 1 == BitInput( bf))
			value |= mask;
		mask >>= 1;
	}
	return value;
}

void BitOutput( BITFILE *bf, int bit){
	if( 0 != bit) bf->rack |= bf->mask;
	bf->mask >>= 1;
	if( 0 == bf->mask){	// eight bits in rack
		fputc( bf->rack, bf->fp);
		bf->rack = 0;
		bf->mask = 0x80;
	}
}

void BitsOutput( BITFILE *bf, unsigned long code, int count){
	unsigned long mask;

	mask = 1L << (count-1);
	while( 0 != mask){
		BitOutput( bf, (int)(0==(code&mask)?0:1));
		mask >>= 1;
	}
}
#if 0
int main( int argc, char **argv){
	BITFILE *bfi, *bfo;
	int bit;
	int count = 0;

	if( 1<argc){
		if( NULL==OpenBitFileInput( bfi, argv[1])){
			fprintf( stderr, "fail open the file\n");
			return -1;
		}
	}else{
		if( NULL==OpenBitFileInput( bfi, NULL)){
			fprintf( stderr, "fail open stdin\n");
			return -2;
		}
	}
	if( 2<argc){
		if( NULL==OpenBitFileOutput( bfo, argv[2])){
			fprintf( stderr, "fail open file for output\n");
			return -3;
		}
	}else{
		if( NULL==OpenBitFileOutput( bfo, NULL)){
			fprintf( stderr, "fail open stdout\n");
			return -4;
		}
	}
	while( 1){
		bit = BitInput( bfi);
		fprintf( stderr, "%d", bit);
		count ++;
		if( 0==(count&7))fprintf( stderr, " ");
		BitOutput( bfo, bit);
	}
	return 0;
}
#endif

lzw_E.c

/*
 * Definition for LZW coding 
 *
 * vim: ts=4 sw=4 cindent nowrap
 */
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include "bitio.h"
#define MAX_CODE 65535

//定义词典的结构
struct {
	int suffix;       //尾缀字符
	int parent, firstchild, nextsibling;    //母节点，第一个孩子节点，下一个兄弟节点
} dictionary[MAX_CODE+1];
int next_code;
int d_stack[MAX_CODE]; // stack for decoding a phrase

#define input(f) ((int)BitsInput( f, 16))
#define output(f, x) BitsOutput( f, (unsigned long)(x), 16)

int DecodeString( int start, int code);
void InitDictionary( void);
void PrintDictionary( void){
	int n;
	int count;
	for( n=256; n<next_code; n++){
		count = DecodeString( 0, n);
		printf( "%4d->", n);
		while( 0<count--) printf("%c", (char)(d_stack[count]));
		printf( "\n");
	}
}

int DecodeString( int start, int code){
	int count;
	count = start;
	while( 0<=code){
		d_stack[ count] = dictionary[code].suffix;
		code = dictionary[code].parent;
		count ++;
	}
	return count;
}
void InitDictionary( void){
	int i;

	for( i=0; i<256; i++){
		dictionary[i].suffix = i;
		dictionary[i].parent = -1;
		dictionary[i].firstchild = -1;
		dictionary[i].nextsibling = i+1;
	}
	dictionary[255].nextsibling = -1;
	next_code = 256;
}
/*
 * Input: string represented by string_code in dictionary,
 * Output: the index of character+string in the dictionary
 * 		index = -1 if not found
 */
int InDictionary( int character, int string_code){
	int sibling;
	if( 0>string_code) return character;
	sibling = dictionary[string_code].firstchild;
	while( -1<sibling){
		if( character == dictionary[sibling].suffix) return sibling;
		sibling = dictionary[sibling].nextsibling;
	}
	return -1;
}

void AddToDictionary( int character, int string_code){
	int firstsibling, nextsibling;
	if( 0>string_code) return;
	dictionary[next_code].suffix = character;
	dictionary[next_code].parent = string_code;
	dictionary[next_code].nextsibling = -1;
	dictionary[next_code].firstchild = -1;
	firstsibling = dictionary[string_code].firstchild;
	if( -1<firstsibling){	// the parent has child
		nextsibling = firstsibling;
		while( -1<dictionary[nextsibling].nextsibling ) 
			nextsibling = dictionary[nextsibling].nextsibling;
		dictionary[nextsibling].nextsibling = next_code;
	}else{// no child before, modify it to be the first
		dictionary[string_code].firstchild = next_code;
	}
	next_code ++;
}

void LZWEncode( FILE *fp, BITFILE *bf){
	int character;
	int string_code;
	int index;
	unsigned long file_length;

	fseek( fp, 0, SEEK_END);
	file_length = ftell( fp);
	fseek( fp, 0, SEEK_SET);
	BitsOutput( bf, file_length, 4*8);
	InitDictionary();
	string_code = -1;
	while( EOF!=(character=fgetc( fp))){
		index = InDictionary( character, string_code);
		if( 0<=index){	// string+character in dictionary
			string_code = index;
		}else{	// string+character not in dictionary
			output( bf, string_code);
			if( MAX_CODE > next_code){	// free space in dictionary
				// add string+character to dictionary
				AddToDictionary( character, string_code);
			}
			string_code = character;
		}
	}
	output( bf, string_code);
}

void LZWDecode( BITFILE *bf, FILE *fp){
	int character;
	int new_code, last_code;
	int phrase_length;
	unsigned long file_length;

	file_length = BitsInput( bf, 4*8);
	if( -1 == file_length) file_length = 0;
	InitDictionary();
	last_code = -1;
	while (0 < file_length) {
		new_code = input(bf);
		if (new_code >= next_code) { // this is the case CSCSC( not in dict)
			d_stack[0] = character;
			phrase_length = DecodeString(1, last_code);
		}
		else {
			phrase_length = DecodeString(0, new_code);
		}
		character = d_stack[phrase_length - 1];
		while (0 < phrase_length) {
			phrase_length--;
			fputc(d_stack[phrase_length], fp);
			file_length--;
		}
		if (MAX_CODE > next_code) {    // add the new phrase to dictionary
			AddToDictionary(character, last_code);
		}
		last_code = new_code;
	}
}

int main( int argc, char **argv){
	FILE *fp;
	BITFILE *bf;
	//调试需要4个输入参数，分别是argv[0]:提示使用方法（编解码标识符=输入文件+输出文件），argv[1]：'E'/'D'（选择编码还是解码），argv[2]：读入文件，argv[3]：读出文件
	if( 4>argc){
		fprintf( stdout, "usage: \n%s <o> <ifile> <ofile>\n", argv[0]);
		fprintf( stdout, "\t<o>: E or D reffers encode or decode\n");
		fprintf( stdout, "\t<ifile>: input file name\n");
		fprintf( stdout, "\t<ofile>: output file name\n");
		return -1;
	}
	if( 'E' == argv[1][0]){               // do encoding
		fp = fopen( argv[2], "rb");
		bf = OpenBitFileOutput( argv[3]);
		if( NULL!=fp && NULL!=bf){
			LZWEncode( fp, bf);
			fclose( fp);
			CloseBitFileOutput( bf);
			fprintf( stdout, "encoding done\n");
		}
	}else if( 'D' == argv[1][0]){	      // do decoding
		bf = OpenBitFileInput( argv[2]);
		fp = fopen( argv[3], "wb");
		if( NULL!=fp && NULL!=bf){
			LZWDecode( bf, fp);
			fclose( fp);
			CloseBitFileInput( bf);
			fprintf( stdout, "decoding done\n");
		}
	}else{	// otherwise
		fprintf( stderr, "not supported operation\n");
	}
	return 0;
}

 

 

 

qq_43310997
关注
LZW压缩算法原理解析
weixin_33895475的博客
09-30 2857
最近整理Github上以前胡乱写的代码，发现自己还写过压缩算法，大概是不知道什么时候用来练手的。里面我实现了哈夫曼树，LZW字典和算数编码三种压缩算法，时隔几年几乎没什么印象了，尤其是后两种连原理都基本忘了，所以把它们拎出来整理一下，也算是逼自己做个回忆。 本篇先讲LZW算法，Wiki里给出的介绍和样例其实还不错，不过我在网上并没有找到很...
LZW编码及解码实现
06-14
设计一个LZW编码解码系统，掌握LZW编码的特点、储存方法及基本原理。运用理论课知识解决实际问题，选用一种语言实现LZW编码译码的相关函数的基本框架设计，如LZW树的构建，LZW编码的实现，LZW译码的实现。
编程实现LZW编解码
cxrabc的博客
04-10 447
这里写目录标题一、实验目的二、实验思路1. 编码2. 解码3. 数据结构分析三、代码部分1. bitio.h2. bitio.c3. main.c四、结果分析LZW编码的应用 一、实验目的 首先调试LZW的编码程序，以一个文本文件作为输入，得到输出的LZW编码文件。 以实验步骤一得到的编码文件作为输入，编写LZW的解码程序。在写解码程序时需要对关键语句加上注释，并说明进行何操作。重点说明当前码字在词典中不存在时应如何处理并解释原因。 选择至少十种不同格式类型的文件，使用LZW编码器进行压缩得到输出的压缩比
lzw压缩编解码
06-06
用C++实现mfc基于lzw算法的压缩编解码，只要998，代码带回家
lzw编解码器源码及相关lib库
07-25
在本压缩包中，你将找到LZW编解码器的源码以及相关的库文件，这些资源可以帮助你理解和实现LZW算法。 LZW算法的基本原理如下： 1. **初始化字典**：算法开始时，字典包含所有可单个字符的编码，通常是从0到255的...
LZW编解码算法原理及分析
weixin_45859035的博客
07-08 5030
第二类词典编码——LZW编解码算法原理及分析
LZW编解码详解
热门推荐
hanzhen7541的博客
06-07 3万+
最近在看LZW编码和解码，正好看到一篇好文章，在此记录： 转自：https://segmentfault.com/a/1190000011425787 最近整理Github上以前胡乱写的代码，发现自己还写过压缩算法，大概是不知道什么时候用来练手的。里面我实现了哈夫曼树，LZW字典和算数编码三种压缩算法，时隔几年几乎没什么印象了，尤其是后两种连原理都基本忘了，所以把它们拎出来整理一下，也算是逼自...
LZW编解码算法
qq_52247034的博客
04-27 203
一、LZW编码原理 LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新 “ 词条 ” ，然 后用“ 代号 ” 也就是码字表示这个 “ 词条 ” 。这样一来，对字符流的编码就变成了用码字去替 换字符流，生成码字流，从而达到压缩数据的目的。LZW 编码是围绕称为词典的转换表来完成的。LZW 编码器通过管理这个词典完成输入与输出之间的转换。 LZW 编码器的输入是字符流，字符流可以是用8 位 ASCII字符 组成的字符串，而输出是用 n 位 ( 例如 12 位 ) 表示的码字流。 ...
用LZW压缩算法实现的编码与解码
12-30
压缩文件有两个源码文件LZWCode.cpp和LZWDecode.cpp可以实现LZW的编码与解码,并有简要的使用说明文档。
LZW解码过程
11-25
对LZW解码算法通过列表的形式进行简单的讲解~~
简单实现lzw编解码程序
02-18
对输入的字符进行lzw编码 并用码字解码输出。。。。。。。。
lzw的编码分析及实现原理
11-14
LZW 是一种无损数据压缩算法，是对1978 年发表的 LZ78 的改进。LZW应用于Unix系统的标准工具、GIF图片格式以及TIFF格式等。同时LZW压缩算法对于较大规模的英文文本的压缩具有良好的效果，一般可以压缩到原来大小的一半。然而LZW的专利曾一度限制了其使用范围，不过，LZW专利于2003年过期。对事物的好奇心驱使我深入学习LZW压缩和解压缩算法。
LZW编解码实验报告（含程序和注释）
05-26
信息论与编码的实验题目，注释详细，程序可以运行，结果正确。
LZW编码与解码
weixin_44221452的博客
04-09 1184
C语言实现LZW编、解码 文件格式 编码前文件大小/字节 编码后文件大小/字节 压缩效率/ % txt 294 376 127.9 bmp 1,027,604 7,823 0.8 png 2,925,527 3,638,558 124.4 avi 24,641,536 27,367,833 111.1 yuv 98,304 69,632 70.8 docx 812,032 1,016,832 125.2 pdf 56,518,246 69,415,731 112.8
c++之LZW解码
hehui0316的博客
04-24 466
原理： 1、初始状态，词典里包含所有可能的前缀根。 2、cW：=码字流中的第一个码字。输出当前缀-符串cW到字符流 3、 赋值pW=cW。 4、读入下一个符号cW。 5、在字典里查找cW， 如果: a. cW在字典里： (1) 解码cW，即输出 Str(cW)。 (2) 令P=Str(pW)，C=Str(cW)的第一个字符。 (3) 在字典中为P+C添加新的记号映射。 b. cW不在字...
LZW编码
BIN_markie的博客
04-24 3541
一、概述 LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新 “ 词条 ” ，然后用 “ 代号 ” 也就是码字表示这个 “ 词条 ” 。这样一来，对字符流的编码就变成了用码字去替 换字符流，生成码字流，从而达到压缩数据的目的。 LZW编码是围绕称为词典的转换表来完成的， LZW 编码器通过管理这个词典完成输入与输出之间的转换。 LZW编码器的输 入是字符流，字符流可以是用 8 位 ASCII 字符组成的字符串，而输出是用 n 位 ( 例如 ...
LZW示例代码
deadgamer的博客
04-21 158
头文件 #ifndef __BITIO__ #define __BITIO__ #include <stdio.h> typedef struct { FILE* fp; unsigned char mask; int rack; }BITFILE; BITFILE* OpenBitFileInput(char* filename); BITFILE* OpenBitFileOutput(char* filename); void CloseBitFileInput(BITFILE*
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值