【数据压缩】LZW编解码原理及算法实现

一、LZW简介

LZW压缩（LZW compression）是一种由Abraham Lempel、Jacob Ziv和Terry Welch发明的基于表查寻算法把文件压缩成小文件的无损压缩方法。
LZW算法又叫“串表压缩算法”就是通过建立一个字符串表，用较短的代码来表示较长的字符串来实现压缩。
其基本原理为提取原始文件数据中的不同字符，基于这些字符创建一个编译表，然后用编译表中的字符索引来替代原始文件数据中的相应字符，减少原始数据大小。这里的编译表不是事先创建好的，而是根据原始文件数据动态创建的，解码时还要从已编码的数据中还原出原来的编译表。

二、LZW编解码算法及举例

1、LZW编码算法思想

LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新“词条”，然后用“代号”也就是码字表示这个“词条”。这样一来，对字符流的编码就变成了用码字去替换字符流，生成码字流，从而达到压缩数据的目的。LZW编码是围绕称为词典的转换表来完成的。LZW编码器通过管理这个词典完成输入与输出之间的转换。LZW编码器的输入是字符流，字符流可以是用8位ASCII字符组成的字符串，而输出是用n位(例如12位)表示的码字流。
LZW编码算法的步骤如下：
步骤1：将词典初始化为包含所有可能的单字符（常用ASCII码表），
当前前缀P初始化为空。
步骤2：当前字符C=字符流中的下一个字符。
步骤3：判断P＋C是否在词典中。
（1）如果“是”，则用C扩展P，即让P=P＋C，返回到步骤2。
（2）如果“否”，则
输出与当前前缀P相对应的码字W；
将P＋C添加到词典中；
令P=C，并返回到步骤2。

举例：输入流 a b b a b a b a c 

首先，以ASCII码为基础词典

已编码：a b

1. 遇到a，用97表示，编码为97。
2. 遇到b，用98表示，编码为98。
3. 发现ab，加入词典，ab索引为256。

已编码：a b b a b

5. 遇到b，编码为98，发现bb，加入词典，索引为257。
6. 遇到a，发现ba，加入词典，索引为258。
7. 遇到b，ab已存在词典内，编码为256。

已编码：a b b a b a b a c

8. 遇到a，发现aba，加入词典，索引为259。
9. 遇到b，ab已存在词典。
10. 遇到a， aba已存在词典内，编码为259。（这里刚加入词典就用到了）
11. 遇到c，编码为99，发现abac，加入词典，索引为260。
12. 编码结束，编码码流和输入码流对比为：

a  b  b  a  b  a  b  a  c
97 98 98 256     259    99

输入：8bit × 9=72bit
输出：9bit × 6=54bit

2、LZW解码算法思想

LZW解码算法开始时，译码词典和编码词典相同，包含所有可能的前缀根。具体解
码算法如下：
步骤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）如果”否”，结束。
解码过程举例：

97 98 98 256 259 99

1. 遇到97，在基础词典，解码为a。
2. 遇到98，在基础词典，解码为b，发现ab，可知256对应ab。
3. 遇到98，在基础词典，解码为b，发现bb，可知257对应bb。
4. 遇到256，解码为ab，发现ba，可知258对应ba。

已编码：a b b a b

5. 遇到259，目前词典没有259，为什么会发生这种情况？
   只有当码字刚加入词典就被用于编码时，才会出现这一情况，则下一个字符（这里的第六个字符）与上一个码字构成新加入词典的码字，并与后面字符共同编码为这一码字。故而这一字符，与上一个码字的头个字符相同。
6. 259解码为aba（“ab"+“a”）。
7. 遇到99，在基础词典，解码为c。
8. 解码结束。

已解码：a b b a b a b a c

三、LZW编码算法实现

1、数据结构

struct {
   
   //词典节点结构体
	int suffix; //后缀字符
	int parent, firstchild, nextsibling;//母节点、第一个孩子节点、兄弟节点
} dictionary[MAX_CODE+1]; //数组下标为编码

typedef struct{
   
   //二进制文件结构体
	FILE *fp;//输出文件指针
	unsigned char mask;//掩码
	int rack;//缓存，每写入8位，写入rack
}BITFILE;

2、编码代码分析

（1）编码总流程

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);//将输入文件大小写入输出文件。32位表示文件大小
	InitDictionary();//词典初始化
	string_code = -1;//前缀初始化
	while( EOF!=(character=fgetc( fp))){
   
   //依次扫描输入文件，取出各字符
		index = InDictionary( character, string_code);//判断码字string+character是否在词典中
		if( 0<=index){
   
   	// string+character在词典中
			string_code = index;//将string+character对应编码作为前缀
		}else{
   
   	// string+character不在词典中
			output( bf, string_code);//输出前缀
			if( MAX_CODE > next_code){
   
   	// 若词典有剩余空间
				// 将string+character加入词典
				AddToDictionary( character, string_code);
			}
			string_code = character;//将新字符作为新的前缀
		}
	}
	output( bf, string_code);//文件扫描完毕，将最后未输出的前缀输出
}

（2）词典初始化

void InitDictionary( void){
   
   //词典初始化即将0-255根节点初始化
	int i;

	for( i=0; i<256; i++){
   
   //下标为ASCII码值
		dictionary[i].suffix = i;//根的后缀字符为对应ASCII码
		dictionary[i].parent = -1;//没有母节点
		dictionary[i].firstchild = -1;//暂时没有第一个孩子节点
		dictionary[i].nextsibling = i+1;//下一个兄弟节点下标为下一个ASCII码值
	}
	dictionary[255].nextsibling = -1;//最后一个根节点没有下一个兄弟节点
	next_code = 256;//下一个编码为256
}

（3）判断码字是否在词典中

int InDictionary( int character, int string_code){
   
   //判断码字string+character是否在词典中 string_code前缀 character后缀 
	int sibling;
	if( 0>string_code) return character;//文件第一个字符，故而编码为character的ASCII码值
	/*自左向右遍历string_code节点的所有孩子（第一个孩子的所有兄弟）*/
	sibling = dictionary[string_code].firstchild;//string_code节点的第一个孩子
	while( -1<sibling){
   
   //sibling=-1时说明所有兄弟遍历结束
		if( character == dictionary[sibling].suffix) return sibling;//若找到兄弟节点的后缀是character，则返回此节点的编码即下标sibling
		sibling = dictionary[sibling].nextsibling;//若该兄弟节点后缀不是character，则寻找下一个兄弟节点
	}
	return -1;//若遍历所有兄弟节点的后缀后，都找不到该字符，说明string+character不在字典中，返回-1
}

（4）将码字添加到词典中

void AddToDictionary( int character, int string_code){
   
   //码字不在词典，添加进词典中，并编码为next_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){
   
   	// 若新节点的母亲节点原本有孩子
		nextsibling = firstsibling;
		while( -1<dictionary[nextsibling].nextsibling ) //循环找到该母亲节点的最后一个孩子即新节点的最后一个兄弟
			nextsibling = dictionary[nextsibling].nextsibling;
		dictionary[nextsibling].nextsibling = next_code;//将新节点设为最后一个兄弟的下一个兄弟
	}else{
   
   // 若新节点的母亲节点原本没有孩子
		dictionary[string_code].firstchild = next_code;//则新节点是母亲节点的第一个孩子
	}
	next_code ++;//下一个编码增加1
}

（5）打开二进制文件

BITFILE *OpenBitFileOutput( char *filename){
   
   //输出文件名
	BITFILE *bf;
	bf = (BITFILE *)malloc( sizeof(BITFILE