LZW编码算法实现

目录

一、实验原理

1.编码

流程图

原理

2.解码 

流程图

原理

二、实验代码（含注释） 

bitio.h

bitio.c

lzw.c

三、实验结果

1.简单的txt文本测试编解码算法代码

 2.对十种不同格式的文件进行编码压缩，查看压缩效率

 四、实验分析

---

一、实验原理

1.编码

• 流程图

  

• 原理

        LZW编码是围绕称为词典的转换表来完成的。LZW编码器通过管理这个词典完成输入与输出之间的转换。LZW编码器的输入是字符流，字符流可以是用8位ASCII字符组成的字符串，而输出是用n位(例如12位)表示的码字流。

步骤：

步骤1：将词典初始化为包含所有可能的单字符，当前前缀P初始化为空。
步骤2：当前字符C=字符流中的下一个字符。
步骤3：判断P＋C是否在词典中。
（1）如果“是”，则用C扩展P，即让P=P＋C，返回到步骤2。
（2）如果“否”，则
        输出与当前前缀P相对应的码字W；
        将P＋C添加到词典中；
        令P=C，并返回到步骤2。

2.解码 

• 流程图

• 原理

步骤1：在开始译码时词典包含所有可能的前缀根。
步骤2：令CW：=码字流中的第一个码字。
步骤3：输出当前缀-符串string.CW到码字流。
步骤4：先前码字PW：=当前码字CW。
步骤5：当前码字CW：=码字流的下一个码字。
步骤6：判断当前缀-符串string.CW 是否在词典中。
（1）如果”是”，则把当前缀-符串string.CW输出到字符流。
        当前前缀P：=先前缀-符串string.PW。
        当前字符C：=当前前缀-符串string.CW的第一个字符。
        把缀-符串P+C添加到词典。
（2）如果”否”，则当前前缀P：=先前缀-符串string.PW。
        当前字符C：=当前缀-符串string.CW的第一个字符。
        输出缀-符串P+C到字符流,然后把它添加到词典中。
步骤7：判断码字流中是否还有码字要译。
（1）如果”是”，就返回步骤4。
（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; //类似于缓存，每写完8位，将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
 */

#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; //初始化掩码为1000 0000
	bf->rack = 0;  //初始化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){
	//如果bit为1，则在rack下一个未写码位置由0变为1。如果bit为0，则rack不作处理，mask直接向右移位，代表下一个未写码位置为0
	if( 0 != bit) 
		bf->rack |= bf->mask;
	bf->mask >>= 1;
	//每次mask移位后，都要判断mask是否溢出为0。若溢出，则代表成功累计写入八位，即该字节已写满。
	//直接输出rack后，rack初始化为0，mask初始化为1000 0000。
	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){  //mask为0时，说明code共count位数字输出完毕
		BitOutput( bf, (int)(0==(code&mask)?0:1)); //按位输出code
		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.c

/*
 * Definition for LZW coding 
 *
 * vim: ts=4 sw=4 cindent nowrap
 */
#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 (code >= 0) { //当code = -1时，已经到达树根
		d_stack[count] = dictionary[code].suffix; //将下标为code节点中的后缀字母放置于数组相应位置
		code = dictionary[code].parent;  //节点上移至母节点处
		count++; //数组下标+1
	}
	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){// 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; //如果该孩子节点的尾缀字符与C相同，则找到并返回该节点
		sibling = dictionary[sibling].nextsibling; //指向下一个兄弟节点，继续判断C是否是该节点的子节点
	}
	return -1; //词典中没有PC则返回-1
}

//把新的字符串加入到字典中
void AddToDictionary( int character, int string_code){
	int firstsibling, nextsibling;
	if( 0>string_code) //如果是单个字符
		return;
	dictionary[next_code].suffix = character;  //C
	dictionary[next_code].parent = string_code; //P
	dictionary[next_code].nextsibling = -1;  //不存在下一个兄弟节点
	dictionary[next_code].firstchild = -1;  //不存在孩子节点
	firstsibling = dictionary[string_code].firstchild;
	if( -1<firstsibling){	// the parent has child
		nextsibling = firstsibling; //找到P的第一个孩子节点
		while( -1<dictionary[nextsibling].nextsibling ) //该孩子节点存在下一个兄弟节点
			nextsibling = dictionary[nextsibling].nextsibling;  //指向下一个兄弟节点
		dictionary[nextsibling].nextsibling = next_code; //找到最后一个，将nextcode作为该节点的下一个兄弟节点
	}else{// no child before, modify it to be the first
		dictionary[string_code].firstchild = next_code; //若没找到firstchild，nextcode就是firstchild
	}
	next_code ++;
}

//编码部分
void LZWEncode( FILE *fp, BITFILE *bf){
	int character;  //C
	int string_code;  //P
	int index; //PC
	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;  //P为空
	while( EOF!=(character=fgetc( fp))){ //往后读一个字符,判断PC是否在字典里
		index = InDictionary( character, string_code); //判断PC是否在字典里
		if( 0<=index){	// string+character in dictionary
			string_code = index; //PC→P
		}else{	// string+character not in dictionary
			output( bf, string_code); //输出P
			if( MAX_CODE > next_code){	// free space in dictionary
				// add string+character to dictionary
				AddToDictionary( character, string_code);
			}
			string_code = character; //C→P
		}
	}
	output( bf, string_code); //输出P
}

//解码部分
void LZWDecode( BITFILE *bf, FILE *fp){
	int new_code, last_code;
	int character = NULL; 
	int phrase_length; //输出字符串的长度
	unsigned long file_length; //输出文件长度

	file_length = BitsInput(bf, 4 * 8);//输入文件起始处存储输出文件的大小
	if (-1 == file_length) 
		file_length = 0;
	InitDictionary(); //初始化词典
	last_code = -1; //初始时没有旧编码，故用-1表示不存在
	while (file_length > 0)  //还没有读到文件末尾
	{
		new_code = input(bf);  //读取新编码
		if (new_code < next_code) //新编码在词典里
		{
			//遍历新编码new_code所在树，将new_code对应字符串放置于d_stack栈数组中。
			//前缀放于栈底方向，后缀位于栈顶d_stack[0]。得到字符总数，即要输出字符串的长度
			phrase_length = DecodeString(0, new_code);
		}
		else //新编码不在词典中
		{
			d_stack[0] = character; //后缀为character
			phrase_length = DecodeString(1, last_code); //前缀为旧编码last_code 
		}
		//当新读取的编码不存在于字典中时，character为旧编码last_code的首字母;
		//当新读取的编码字典中存在时，character为新编码new_code的首字母。
		character = d_stack[phrase_length - 1];
		//此时d_stack中：
		//新读取的编码不存在于字典中时：旧编码last_code对应字符串+last_code对应首字母。
		//当新读取的编码存在于字典中时：新编码new_code对应字符串
		while (0 < phrase_length) //输出d_stack中所存放的字符串
		{
			phrase_length--;
			fputc(d_stack[phrase_length], fp);
			file_length--;
		}
		if (MAX_CODE > next_code)// free space in dictionary
		{
			// add string+character to dictionary
			AddToDictionary(character, last_code);
		}
		last_code = new_code; //新编码变为旧编码
	}
}



int main( int argc, char **argv){
	FILE *fp;
	BITFILE *bf;

	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;
}

三、实验结果

1.简单的txt文本测试编解码算法代码

编码前：

 编码后：

 解码后：

 2.对十种不同格式的文件进行编码压缩，查看压缩效率

原始文件类型	原始文件大小	压缩后文件的大小	压缩效率
bmp	1.97MB	2.39MB	-21.32%
docx	391KB	498KB	-27.37%
jpg	82.7KB	117KB	-41.48%
mp3	55.4KB	79.5KB	-43.50%
pdf	1.17MB	1.34MB	-14.53%
png	998KB	1.21MB	-24.85%
pptx	1.37MB	1.70MB	-24.09%
txt	9Bytes	16Bytes	-77.78%
wav	62.5KB	69.0KB	-10.40%
yuv	43.5MB	29.1MB	33.10%

 四、实验分析

1.LZW算法适合用于压缩较大的文字类型文件：文件中文字的冗余度越高，压缩效率越好；相反，在字符串重复概率低时，影响压缩效率。
2.对于一些已经压缩的文件类型(例如png)，由于其压缩编码已经文件中大部分相关性去除，每个符号近似于等概分布，其信息熵接近于每符号最大值。在这种情况下文件中很少出现重复字符串，严重影响LZW算法效率，甚至压缩效率为负数。