LZW词典编码原理及代码实现

一、LZW词典编码

LZW词典编码，英文名称Lempel-Ziv-Welch算法，是由Abraham Lempel、Jacob Ziv和Terry Welch创建的通用无损数据压缩算法，属于第二类词典编码。它由 Welch 于 1984 年发布，作为 Lempel 和 Ziv 于 1978 年发布的LZ78算法的改进实现。该算法实现简单，并且在硬件实现中具有非常高的吞吐量的潜力。它是广泛使用的Unix文件压缩实用程序compress的算法，用于GIF图像格式。

二、LZW词典编码原理

根据字符串中字符具有重复性这一特点，LZW算法通过提取分析字符串，将已知的字符串用词典中的代号表示，遇到未知的字符串，将其标号放入构建词典中。随着字符串的输入，就可以通过相关编号记录原始数据流中一长串字符串，从而节省空间，压缩数据。

三、LZW词典编码步骤

词典编码算法输出的是词典中字符串的码字，因此最开始词典中不能为空，它必须包含可能在字符流中出现的所有单个字符。

1. 词典初始化包含所有的单字符
2. 读取字符串
3. 读取的一个字符string 1观察是否在词典中
   • 若string 1为第一个字符则一定在词典中
4. 若string 1在词典中，则多读一位，查询词典中string 1 + string 2是否在词典中
   • 若string 1 + string 2不在词典中，则将string 1 + string 2编入词典中，然后用string 1对应的码字给string 1编码
     • 再次读取，若string 2 + string 3不在词典中，则将string 2 + string 3编入词典中，然后用string 2 对应的码字给string 2 编码
     • 依此类推……
   • 若string 1 + string 2在词典中，则多读一位，查询词典中string 1 + string 2 + string 3是否在词典中
     • 若string 1 + string 2 + string 3不在词典中，将string 1 + string 2 + string 3编入词典，然后用string 1 + string 2对应的码字给string 1 + string 2编码
     • 依次类推……

四、LZW解码步骤

词典编码时，词典中必须包含可能在字符流中出现的所有单个字符。在接收端这边一定有最原始的词典。因此收到的第一个码字可以直接解码。

1. 收到的码流中，第一个码字number 1可直接解码
2. 分析第二个码字number 2
   • 若number 2在词典中，则将number 2解码，并将number 1 + number 2对应的string 1 + string 2的第一个字符编入词典中
   • 若number 2不在词典中，则将number 1对应的string 1的第一个字符复写到string 1的后面编入词典并解码，即将string 1 + string 1的第一个字符编入词典。
   • 依此类推……

五、LZW算法实现

LZW编码算法：

struct {//词典节点结构体
	int suffix; //后缀字符
	int parent, firstchild, nextsibling;//母节点、第一个孩子节点、兄弟节点
} dictionary[MAX_CODE+1]; //数组下标为编码
typedef struct{//二进制文件结构体
	FILE *fp;//输出文件指针
	unsigned char mask;//掩码
	int rack;//缓存，每写入8位，写入rack
}BITFILE;



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);//文件扫描完毕，将最后未输出的前缀输出
}
 
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
}
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
}
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
}
BITFILE *OpenBitFileOutput( char *filename){//输出文件名
	BITFILE *bf;
	bf = (BITFILE *)malloc( sizeof(BITFILE));
	if( NULL == bf) return NULL;
	if( NULL == filename)	bf->fp = stdout;//如果参数为NULL，则指向屏幕
	else bf->fp = fopen( filename, "wb");//以二进制只写的方式打开文件
	if( NULL == bf->fp) return NULL;
	bf->mask = 0x80;//掩码为10000000
	bf->rack = 0;//缓存为0
	return bf;
}void BitsOutput( BITFILE *bf, unsigned long code, int count){
	unsigned long mask;
	/*计算掩码值，位数为count的数值且最高位为1，例如若count为16，则mask=1000 0000 0000 0000*/
	mask = 1L << (count-1);
	while( 0 != mask){//mask为0时，说明code的count位数字输出完毕，注意：LZW是等长码
		BitOutput( bf, (int)(0==(code&mask)?0:1));//按位输出code
		mask >>= 1;//掩码向右移位
	}
}
void BitOutput( BITFILE *bf, int bit){
	/*若bite=1，则本code输出结束，此时mask为1，rack为0,则缓存rack变为1
	若bit=0，则尚未输出结束，此时mask向右移位，为0，rack不变*/
	if( 0 != bit) bf->rack |= bf->mask;
	bf->mask >>= 1;//mask向右移1位
	/*若mask溢出为0，则表示成功累计写入8位，则直接输出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;
	}
}

LZW解码算法

void LZWDecode( BITFILE *bf, FILE *fp){
	//需填写
	int character;//新/旧编码首字母
	int new_code;//新编码
	int last_code = -1;//起初旧编码空缺，初始化为-1
	int string_length;//输出字符串长度
	unsigned long file_length;//输出文件大小
 
	file_length = BitsInput(bf, 4*8);//输入文件起始处为输出文件大小，共32位
	if (-1 == file_length) file_length = 0;//若文件无内容，大小为0
	InitDictionary();//词典初始化，设置0-255的根节点
	while (file_length > 0) {//若读取到最后一个编码，结束循环
		new_code = input(bf);//16位读取新编码
		if (new_code >= next_code) {//若字典中没有新编码
			d_stack[0] = character;//character为旧编码last_code的首字母，将其放置在数组d_stack[0]首位
			/*遍历旧编码last_code所在树，将last_code对应字符串放入d_stack，前缀在栈底，后缀在d_stack[1]。返回字符串长度*/
			string_length = DecodeString(1, last_code);
		}
		else {//若字典中已有新编码
			/*遍历新编码new_code所在树，将new_code对应字符串放入d_stack，前缀在栈底，后缀在d_stack[0]。返回字符串长度*/
			string_length = DecodeString(0, new_code);
		}
		/*若新读取的编码不存在于词典中，character为旧编码last_code的首字母
		若新读取的编码存在于词典中，character为新编码new_code的首字母*/
		character = d_stack[string_length - 1];
		/*若新读取的编码不存在于词典中，输出旧编码last_code对应字符串+last_code的首字母
		若新读取的编码存在于词典中，输出新编码new_code对应字符串*/
		while (string_length > 0) {
			string_length--;
			fputc(d_stack[string_length], fp);
			file_length--;
		}
		/*若新读取的编码不存在于词典中，将last_code对应字符串+last_code的首字母添加到词典
		若新读取的编码存在于词典中，将last_code对应字符串+new_code的首字母添加到词典*/
		if (MAX_CODE > next_code) {
			AddToDictionary(character, last_code);
		}
		last_code = new_code;//新编码变为旧编码
	}
}