【数据压缩】第五次作业——LZW编码

已于 2022-04-17 23:09:37 修改
阅读量562 收藏 5
点赞数 1
分类专栏： 数据压缩 文章标签： 其他
于 2022-04-17 23:05:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QKKKKathy/article/details/124238385
版权

LAW编码

文章目录

LZW的编码思想是不断从字符流中提取新的“词条”，然后用码字来表示这个“词条”，LZW编码是围绕“词典”转换表完成的。LZW编码器通过管理这个词典完成输入和输出之间的转换，输入是字符流，输出是n位表示的码字流。解码端输入码字流，边解码边建立词典，得到输出字符流。

编码原理

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

LZW编码算法首先初始化词典，然后顺序从待压缩文件中读入字符并按照上述算法执行编码，最后将编得的码字流输出至文件中。

在这里插入图片描述

解码原理

  • Step 1：在开始译码时词典包含所有可能的前缀根
  • Step 2：令CW：=码字流中的第一个码字。
  • Step 3：输出当前缀-字符串string.CW到码字流。
  • Step 4：先前码字PW：=当前码字CW。
  • Step 5：当前码字CW：=码字流的下一个码字。
  • Step 6：判断当前缀-字符串string.CW 是否在词典中。
    • 如果”是”，则把当前缀-字符串string.CW输出到字符流。当前前缀P：=先前缀-字符串string.PW，当前字符C：=当前前缀-字符串string.CW的第一个字符。把缀-符串P+C添加到词典。
    • 如果”否”，则当前前缀P：=先前缀-字符串string.PW。 当前字符C：=当前缀-字符串string.CW的第一个字符。 输出缀-符串P+C到字符流,然后把它添加到词典中。
  • Step 7：判断码字流中是否还有码字要译。
    • 如果”是”，就返回步骤4。
    • 如果”否”，结束。

LZW解码算法首先初始化词典，然后顺序从压缩文件中读入码字，并按照上述算法执行解码，最后将解得的字符串输出至文件中

在这里插入图片描述

代码分析

词典树

#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，用来存储解码后的短语

这部分代码用来定义词典树

suffix：当前字符的尾缀字符

parent：当前节点的母节点

firstchild：当前节点的第一个孩子节点

nextsibling：当前节点的下一个兄弟（右边）节点

next_code：记录下一个词条的位置

初始化词典树

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;   //下一个词条的编码
}

这一部分代码用来初始化词典，词典中默认包含ascii码对应的256个字符，如果想要写入新的词条，则需要从第256个位置开始

当前字符是否在词典中

int InDictionary( int character, int string_code){   //判断词典中是否有当前字符character（尾缀），string_code是旧词条（前缀）
	int sibling;    //表示字符在词典中的位置
	if( 0>string_code) return character;    //如果string_code=-1，说明当前字符是单个字符，已经存在词典中了，因此直接返回当前字符即可
	sibling = dictionary[string_code].firstchild;   //找string_code的第一个孩子，如果此时string_code没有第一个孩子则sibling=-1
	while( -1<sibling){   //sibling>-1，表示string_code已经有孩子了，也就是已经有尾缀了
		if( character == dictionary[sibling].suffix) return sibling;   //如果当前字符与string_code的某一个尾缀相同，那么返回这个尾缀
		sibling = dictionary[sibling].nextsibling;  //每次循环后都让sibling的值等于它的下一个兄弟节点
	}
	return -1;    //如果没有找到就返回-1
}

如果输入的是单个字符，那么直接返回这个字符

如果不是，就找到它的第一个孩子节点，也就是第一个尾缀，判断是否与当前新字符相同，如果不同就找这个孩子节点的兄弟节点，直到所有孩子节点都找完。在这个过程中，如果有某一个孩子节点与当前的新字符相同，那么函数返回此时的sibling，如果找不到就返回-1

添加新字符

在词典树中的添加新字符

首先添加新字符的上下和右向关系，新字符的前缀是string_code，孩子节点和右边的兄弟节点都是-1。

再补充新字符的左向关系，通过找新字符前缀的第一个孩子节点，并不断向右，找到这个前缀的最后一个孩子节点后，将最后一个孩子节点的右边兄弟节点更新为当前新字符。

void AddToDictionary( int character, int string_code){  //读入的新字符character（尾缀）和旧词条string_code（前缀）
	int firstsibling, nextsibling;
	if( 0>string_code) return;   //如果string_code<0说明是一个单字符，返回即可
	//描述上下和右向的关系
	dictionary[next_code].suffix = character;   //下一个词条的尾缀为当前新字符
	dictionary[next_code].parent = string_code;  //这个尾缀character的母节点就是它的前缀是string_code
	dictionary[next_code].nextsibling = -1;    //这个尾缀的兄弟节点是-1
	dictionary[next_code].firstchild = -1;     //这个尾缀的第一个孩子节点是-1
	//描述左向的关系
	firstsibling = dictionary[string_code].firstchild;   //找前缀的第一个孩子，也是当前字符的第一个兄弟（最左边的）
	if( -1<firstsibling){	// the parent has child   前缀有孩子
		nextsibling = firstsibling;   //先让下一个兄弟节点为第一个孩子
		while( -1<dictionary[nextsibling].nextsibling )   //循环找兄弟节点的下一个兄弟节点，如果>-1说明还有兄弟节点
			nextsibling = dictionary[nextsibling].nextsibling;  //更新兄弟节点为右边的兄弟节点
		dictionary[nextsibling].nextsibling = next_code;    //直到兄弟节点的右边没有兄弟节点的时候，将新字符作为这个兄弟节点的兄弟节点
															//此时新字符成为了当前前缀为string_code的最后一个孩子（在最右边）
	}else{// no child before, modify it to be the first   前缀没有孩子的时候，当前新字符就是这个前缀的第一个孩子
		dictionary[string_code].firstchild = next_code;   //设置当前字符为前缀的第一个孩子
	}
	next_code ++;    //每添加一个字符，next_code++
}

编码

  • 先利用fseek函数确定读入的需要编码的文件长度
  • 利用InitDictionary函数为词典初始化
  • 循环运行，每次从文件中读取一个字符，直到读不出字符为止，每次读入的字符就是之前说过的C
  • 利用InDictionary函数判断读入的字符是否在词典树中
  • 将InDictionary函数的返回值赋给index变量
  • 如果index>=0说明词典树中有当前字符和旧词条组成的字符串，就将index的值赋给string_code，也就是P<-P+C
  • 如果index<0，就说明词典树中没有当前字符和旧词条组成的字符串，因此利用AddToDictionary函数在词典树中添加新字符
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);   //调用BitsOutput函数
	InitDictionary();    //初始化词典
	string_code = -1;    //初始值赋值为-1，方便在第一次判断的时候判断读取是否为单个字符
	while( EOF!=(character=fgetc( fp))){  //fgetc是从文件中读取一个字符，EOF是文件结束的标志，从文件中读取字符，直到读到结束标志
        //fgetc是从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。格式：int fgetc(FILE *stream);。
		index = InDictionary( character, string_code);    //判断当前字符是否在词典中，返回字符在词典中的index，如果不在则返回-1
		if( 0<=index){	// string+character in dictionary    index>=0说明旧字符+当前新字已经在词典中了
			string_code = index;  //更新当前的旧词条为先前的旧词条+当前的新字符 P<-P+C
		}else{	// string+character not in dictionary    如果index返回-1，说明当前字符不在词典中
			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;   //当前字符变为了旧字符，P<-C
		}
	}
	output( bf, string_code);  //循环读完文件后输出最后一个旧字符
}

解码

  • 解码端也需要先初始化词典，并读取出解码文件的长度
  • 之后进入while循环，每一次循环都是一次解码的过程
    • 如果CW>=next_code，那么就说明当前码字已经不在词典中了。这是因为编码和解码过程实际上是有时差的，编码的时候当输入第二个字符且第一个字符与第二个字符的组合未出现在词典中时，才会把第一个字符对应的码字输出，新的字符写入词典，但是对于解码端来说，只要收到码字就会开始解码。因此，如果在编码端词条刚写入词典就被使用了，这个时候解码端就会因为时差而无法在词典中找到新输入的码字对应的字符。又因为只有在编码端出现形似ababa的字符流时才会产生这样的情况，因此解码端只要收到不在词典中的码字的时候，只需要把上一个码字对应的字符的第一位放到当前码字对应的字符的最后一位即可得到码字的解码字符。所以这个时候令d_stack[0] = character即可，这里character=上一个码字的第一位，而d_stack[0]=当前码字的最后一位，并将上一个码字last_code对应的字符串也写入d_stack。
    • 如果CW<next_code，就说明码字已经在词典中了，可以直接根据词典解码出对应的字符或字符串，因此直接将new_code对应的字符串写入d_stack即可
  • 利用DecodeString函数计算每次解码字符串的长度，返回后令character = d_stack[phrase_length - 1]，也就是当前解码字符串的第一个字符
  • 之后的while循环中就是将倒序存入d_stack的字符串输出到文件中
  • 如果词典中还有空间，就将上一个字符串与当前解码字符串的第一个字符写入词典，同时将当前码字赋值给上一个码字，并进入下一次循环，直到整个文件都解码完为止
void LZWDecode( BITFILE *bf, FILE *fp){
	int character;    //字符
	int new_code, last_code;   //new_code就是CW，表示码流中的下一个码字，last_code就是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;   //先设置前一个码字为-1，因为在第一个码字之前是空值

	while (0 < file_length) {   //当文件长度>0的时候进入循环，也就是仍有未解码的码字时进入循环
		new_code = input(bf);    //定义的输入，从压缩后的文件中读入码字
		if (new_code >= next_code) {   //this is the case CSCSC( not in dict)，除了第一次以外，每次都要判断新的字符是否在词典中
									   //如果新的码字比当前词典中最后一个码字要大，就说明新的码字已经不在词典中了
			d_stack[0] = character;    //先将character给d_stack[0]，如果新的码字不在词典中，那么新的码字对应的最后一个字符就是上一个码字的第一个字符
			phrase_length = DecodeString(1, last_code);  //此时d_stack要从1开始向后存储上一个码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
		}
		else {   //如果新的码字小于等于当前的最后一个码字，说明新码字在词典中
			phrase_length = DecodeString(0, new_code);  //此时d_stack从0开始向后存储新码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
		}
		character = d_stack[phrase_length - 1];   //解码后的最后一个字符，其实是当前码字对应的字符流中的第一个字符
		while (0 < phrase_length) {   //解码存储符号时d_stack是从最后一个子节点倒序存储到最开始的母节点
			phrase_length--;   //因此d_stack是倒序存储的，通过phrase_length来决定此次将多少字符解压缩到文件中
			fputc(d_stack[phrase_length], fp);  //将d_stack中存储的字符写入文件
            //函数功能： 将字符c写到文件指针fp所指向的文件的当前写指针的位置。函数格式：int fputc (int c, FILE *fp)。
			file_length--;  //压缩文件剩余的未解压缩的量
		}
		if (MAX_CODE > next_code) {   //如果此时词典还不满的话
			AddToDictionary(character, last_code);    //将上一个字符（last_code）和当前码字对应字符流中的第一个字符（character）写入词典
		}
		last_code = new_code;   //CW->PW
	}
}
DecodeString

该函数返回每次解码时解码字符串的长度

count用来记录当前码字的解码字符流的长度，d_stack存储解码字符流，每次解压缩的字符串都会倒序存入d_stack，因此向文件中写入的时候需要倒序将里面的内容取出。

start代表从d_stack[0]开始存储还是d_stack[1]开始存储，code表示最后一个子节点对应的码字，通过它来找到子节点的字符并且找到它的母节点对应的码字，循环直到找到最开始的码字。

int DecodeString( int start, int code){
	int count;   //记录当前解码字符流的长度
	count = start;   //从0/1开始
	while (code >= 0) {  //如果还没有找到最开始的母节点
		d_stack[count] = dictionary[code].suffix;   //d_stack中存储解码时对应的字符
		code = dictionary[code].parent;				//是倒序存储的，0存储最后一个子节点，之后不断往上找它的母节点依次向后存入d_stack
		count++;     //每存储一个字符，字符流长度+1
	}
	return count;   //返回字符流长度
}

实验结果

编解码测试

调试LZW的编码程序，以一个文本文件作为输入，得到输出的LZW编码文件。

词典输出

可以输出根据LZW规则建立的词典

void PrintDictionary( void){   //输出256之后的词典
	int n;    
	int count;    //字符串长度
	for( n=256; n<next_code; n++){
		count = DecodeString( 0, n);    //从0开始记录到n的长度
		printf( "%4d->", n);     //输出这是第n个词条
		while( 0<count--) printf("%c", (char)(d_stack[count]));   //输出每一个词条对应的字符串
		printf( "\n");   //换行
	}
}
编码
  • 设置工作目录和命令参数

在这里插入图片描述

  • 查看test.txt文件中的内容

在这里插入图片描述

  • main函数中运行编码部分的指令

    	if( 'E' == argv[1][0]){ // do encoding    argv[1][0]如果是E的话就进行编码
		fp = fopen( argv[2], "rb");    //打开输入文件，编码前的文件
		bf = OpenBitFileOutput( argv[3]);    //打开输出文件，编码后的文件
		if( NULL!=fp && NULL!=bf){      //如果两个文件均不为空
			LZWEncode( fp, bf);     //对输入文件fp编码生成输出文件bf，bf也就是压缩后的文件
			fclose( fp);     //关闭输入文件
			CloseBitFileOutput( bf);    //关闭输出文件
			fprintf( stdout, "encoding done\n");     //输出编码成功
		}

  • 查看压缩后的test_dat.dat文件

在这里插入图片描述

  • 输出词典

    			printf("encode dictionary:\n");
			PrintDictionary();

编码词典在这里插入图片描述
​ .dat并不是一种标准文件。许多文件都使用这个扩展名，但文件含义不同。许多数据分析软件也用这个扩展名保存数据。所以这要看具体的软件情况来定。DAT文件，可以按照扩展名来看就是DATA的意思，即数据文件，这类文件并没有进行绝对化的定义，文件格式其实是不确定的

解码
  • 设置解码命令行参数

在这里插入图片描述

  • main函数中运行解码部分的指令

    else if( 'D' == argv[1][0]){	// do decoding   argv[1][0]如果是D的话就进行解码
		bf = OpenBitFileInput( argv[2]);    //打开输入文件，是压缩后的文件
		fp = fopen( argv[3], "wb");    //以写的方式打开输出文件，是解压缩后的文件
		if( NULL!=fp && NULL!=bf){    //如果两个文件不为空
			LZWDecode( bf, fp);   //对输入文件bf解码生成输出文件fp，fp就是解码后的文件
			fclose( fp);    //关闭输出文件
			CloseBitFileInput( bf);    //关闭输入文件
			fprintf( stdout, "decoding done\n");    //输出解码成功
		}
	}

  • 查看解码后的文件

在这里插入图片描述
解码成功！

  • 输出解码词典

    		printf("decode dictionary:\n");
		PrintDictionary();

在这里插入图片描述在这里插入图片描述

  • 对比编解码文件大小

在这里插入图片描述
发现压缩后的文件大小比原文件还要大，这可能是因为原文件字符重复率比较低而导致

  • 更换一个字符重复率较高的文件

在这里插入图片描述

  • 查看编码后的文件

在这里插入图片描述

  • 对比编码后和解码后文件大小

在这里插入图片描述
观察到这个文件的压缩效果就很好

不同类型的文件

选择至少十种不同格式类型的文件，使用LZW编码器进行压缩得到输出的压缩比特流文件。对各种不同格式的文件进行压缩效率的分析。

原文件

在这里插入图片描述

编码后的文件

在这里插入图片描述

各个文件的编码词典总数

  • 1.py：2418 在这里插入图片描述

  • 2.jpeg：36735 在这里插入图片描述

  • 3.pdf：65534 在这里插入图片描述

  • 4.mp4：65534 在这里插入图片描述

  • 5.docx：9990 在这里插入图片描述

  • 6.yuv：65534 在这里插入图片描述

  • 7.xlsx：7329 在这里插入图片描述

  • 8.md：4582 在这里插入图片描述

  • 9.wav：65534 在这里插入图片描述

  • 10.pptx：43944 在这里插入图片描述

解码恢复后的文件

在这里插入图片描述

经检查，解码恢复后的文件内容与压缩前的文件内容相同

统计分析

在这里插入图片描述

观察到不同文件的压缩率差别非常的大，并且有很多文件在利用词典编码之后反而比原文件大了，猜测可能是因为文件中重复字符的概率较低而导致

LZW编码的特点和应用

  • 优点：LZW只需要一遍扫描，具有自适应的特点；算法简单，便于快速实现（利用数字查找树/建树）
  • 缺点：字符串重复概率低时，影响压缩效率，这是由输入字符流的统计特性决定的，很难解决；词典中的字符串不再出现的时候，会影响压缩效率；从词典中查找词条是算法中最费时的工作
  • LZW编码的应用
    • 通用文件压缩：WinZip
    • 动画图像压缩：GIF，TIFF
    • 电子邮件压缩
    • PDF文档压缩
    • 雷达数据压缩
    • 等等

程序代码

bitio.h

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

#include <stdio.h>
#pragma warning(disable:4703) 
#pragma warning(disable:4996);    //使得fopen在编译时可以通过

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.cpp

/*
 * 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;
	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.cpp

/*
 * 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){   //输出256之后的词典
	int n;    
	int count;    //字符串长度
	for( n=256; n<next_code; n++){
		count = DecodeString( 0, n);    //从0开始记录到n的长度
		printf( "%4d->", n);     //输出这是第n个词条
		while( 0<count--) printf("%c", (char)(d_stack[count]));   //输出每一个词条对应的字符串
		printf( "\n");   //换行
	}
}

int DecodeString( int start, int code){
	int count;   //记录当前解码字符流的长度
	count = start;   //从0/1开始
	while (code >= 0) {  //如果还没有找到最开始的母节点
		d_stack[count] = dictionary[code].suffix;   //d_stack中存储解码时对应的字符
		code = dictionary[code].parent;				//是倒序存储的，0存储最后一个子节点，之后不断往上找它的母节点依次向后存入d_stack
		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){   //判断词典中是否有当前字符character（尾缀），string_code是旧词条（前缀）
	int sibling;    //表示字符在词典中的位置
	if( 0>string_code) return character;    //如果string_code=-1，说明当前字符是单个字符，已经存在词典中了，因此直接返回当前字符即可
	sibling = dictionary[string_code].firstchild;   //找string_code的第一个孩子，如果此时string_code没有第一个孩子则sibling=-1
	while( -1<sibling){   //sibling>-1，表示string_code已经有孩子了，也就是已经有尾缀了
		if( character == dictionary[sibling].suffix) return sibling;   //如果当前字符与string_code的某一个尾缀相同，那么返回这个尾缀
		sibling = dictionary[sibling].nextsibling;  //每次循环后都让sibling的值等于它的下一个兄弟节点
	}
	return -1;    //如果没有找到就返回-1
}

void AddToDictionary( int character, int string_code){  //读入的新字符character（尾缀）和旧词条string_code（前缀）
	int firstsibling, nextsibling;
	if( 0>string_code) return;   //如果string_code<0说明是一个单字符，返回即可
	//描述上下和右向的关系
	dictionary[next_code].suffix = character;   //下一个词条的尾缀为当前新字符
	dictionary[next_code].parent = string_code;  //这个尾缀character的母节点就是它的前缀是string_code
	dictionary[next_code].nextsibling = -1;    //这个尾缀的兄弟节点是-1
	dictionary[next_code].firstchild = -1;     //这个尾缀的第一个孩子节点是-1
	//描述左向的关系
	firstsibling = dictionary[string_code].firstchild;   //找前缀的第一个孩子，也是当前字符的第一个兄弟（最左边的）
	if( -1<firstsibling){	// the parent has child   前缀有孩子
		nextsibling = firstsibling;   //先让下一个兄弟节点为第一个孩子
		while( -1<dictionary[nextsibling].nextsibling )   //循环找兄弟节点的下一个兄弟节点，如果>-1说明还有兄弟节点
			nextsibling = dictionary[nextsibling].nextsibling;  //更新兄弟节点为右边的兄弟节点
		dictionary[nextsibling].nextsibling = next_code;    //直到兄弟节点的右边没有兄弟节点的时候，将新字符作为这个兄弟节点的兄弟节点
															//此时新字符成为了当前前缀为string_code的最后一个孩子（在最右边）
	}else{// no child before, modify it to be the first   前缀没有孩子的时候，当前新字符就是这个前缀的第一个孩子
		dictionary[string_code].firstchild = next_code;   //设置当前字符为前缀的第一个孩子
	}
	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);   //调用BitsOutput函数
	InitDictionary();    //初始化词典
	string_code = -1;    //初始值赋值为-1，方便在第一次判断的时候判断读取是否为单个字符
	while( EOF!=(character=fgetc( fp))){  //fgetc是从文件中读取一个字符，EOF是文件结束的标志，从文件中读取字符，直到读到结束标志
										 //fgetc是从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。格式：int fgetc(FILE *stream);。
		index = InDictionary( character, string_code);    //判断当前字符是否在词典中，返回字符在词典中的index，如果不在则返回-1
		if( 0<=index){	// string+character in dictionary    index>=0说明旧字符+当前新字已经在词典中了
			string_code = index;  //更新当前的旧词条为先前的旧词条+当前的新字符 P<-P+C
		}else{	// string+character not in dictionary    如果index返回-1，说明当前字符不在词典中
			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;   //当前字符变为了旧字符，P<-C
		}
	}
	output( bf, string_code);  //循环读完文件后输出最后一个旧字符
}

void LZWDecode( BITFILE *bf, FILE *fp){
	int character;    //字符
	int new_code, last_code;   //new_code就是CW，表示码流中的下一个码字，last_code就是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;   //先设置前一个码字为-1，因为在第一个码字之前是空值

	while (0 < file_length) {   //当文件长度>0的时候进入循环，也就是仍有未解码的码字时进入循环
		new_code = input(bf);    //重定义的输入，从压缩后的文件中读入码字
		if (new_code >= next_code) {   //this is the case CSCSC( not in dict)，除了第一次以外，每次都要判断新的字符是否在词典中
									   //如果新的码字比当前词典中最后一个码字要大，就说明新的码字已经不在词典中了
			d_stack[0] = character;    //先将character给d_stack[0]，如果新的码字不在词典中，那么新的码字对应的最后一个字符就是上一个码字的第一个字符
			phrase_length = DecodeString(1, last_code);   //此时d_stack要从1开始向后存储上一个码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
		}
		else {   //如果新的码字小于等于当前的最后一个码字，说明新码字在词典中
			phrase_length = DecodeString(0, new_code);  //此时d_stack从0开始向后存储新码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
		}
		character = d_stack[phrase_length - 1];   //解码后的最后一个字符，其实是当前码字对应的字符流中的第一个字符
		while (0 < phrase_length) {   //解码存储符号时d_stack是从最后一个子节点倒序存储到最开始的母节点
			phrase_length--;   //因此d_stack是倒序存储的，通过phrase_length来决定此次将多少字符解压缩到文件中
			fputc(d_stack[phrase_length], fp);  //将d_stack中存储的字符写入文件
												//函数功能： 将字符c写到文件指针fp所指向的文件的当前写指针的位置。函数格式：int fputc (int c, FILE *fp)。
			file_length--;  //压缩文件剩余的未解压缩的量
		}
		if (MAX_CODE > next_code) {   //如果此时词典还不满的话
			AddToDictionary(character, last_code);    //将上一个字符（last_code）和当前码字对应字符流中的第一个字符（character）写入词典
		}
		last_code = new_code;   //CW->PW
	}
}



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

	//测试需要四个参数，argv[1]：'E'/'D'（选择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    argv[1][0]如果是E的话就进行编码
		fp = fopen( argv[2], "rb");    //打开输入文件，编码前的文件
		bf = OpenBitFileOutput( argv[3]);    //打开输出文件，编码后的文件
		if( NULL!=fp && NULL!=bf){      //如果两个文件均不为空
			LZWEncode( fp, bf);     //对输入文件fp编码生成输出文件bf，bf也就是压缩后的文件
			fclose( fp);     //关闭输入文件
			CloseBitFileOutput( bf);    //关闭输出文件
			fprintf( stdout, "encoding done\n");     //输出编码成功

			printf("encode dictionary:\n");
			PrintDictionary();
		}
	}else if( 'D' == argv[1][0]){	// do decoding   argv[1][0]如果是D的话就进行解码
		bf = OpenBitFileInput( argv[2]);    //打开输入文件，是压缩后的文件
		fp = fopen( argv[3], "wb");    //以写的方式打开输出文件，是解压缩后的文件
		if( NULL!=fp && NULL!=bf){    //如果两个文件不为空
			LZWDecode( bf, fp);   //对输入文件bf解码生成输出文件fp，fp就是解码后的文件
			fclose( fp);    //关闭输出文件
			CloseBitFileInput( bf);    //关闭输入文件
			fprintf( stdout, "decoding done\n");    //输出解码成功
		}

		printf("decode dictionary:\n");
		PrintDictionary();

	}else{	// otherwise
		fprintf( stderr, "not supported operation\n");
	}
	return 0;
}

实验总结

通过本次实验可以看到LZW编码方式虽然简单，但是很多时候编码效率并不是很好，这可能是因为对于数据流中连续重复出现的字节和字串，LZW压缩技术具有很高的压缩比，但事实上很多文件中并没有足够多的重复字符，因此无法体现出LZW编码的优势。

QKKKKathy
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA压缩之LZW算法字典压缩与解压
lzq1326253299的博客
09-17 3815
压缩过程： 前面已经写过一篇哈夫曼压缩，LZW字典压缩与哈夫曼压缩的不同之处在于不需要把编码写入文件，编码表是在读文件中生成的，首先将0-255个ASCLL码与对应的数字存入哈希表中，作为基础码表。 这里的后缀为当前 前缀+后缀 如果在码表中存在，前缀等于前缀+后缀。如果不存在，将前缀+后缀所表示的字符串写入编码表编码，同时将前缀写入压缩文件中。这里重点注意一下，一个字节所能表示的数字范围为0-...
第五次作业：LZW编码
wogua7的博客
07-01 823
LZW编码（LZW Encoding）又称“串表压缩算法”，由J.Ziv和A.Lempel在1978年首次介绍，并由Terry A.Welch在1984年予以改进，最终该编码方法由三人的名字命名。该编码方法属于词典压缩编码方法。词典编码是一种通用编码方法，适用于无法观察新源统计特性，或虽然可观察但统计特性不固定的情形。LZW编码可应用于通用文件压缩（如WinZip）、动画图像压缩（如GIF、TIFF）等领域。下面将介绍LZW编解码的基本原理和C++的实现方法。LZW编码的核心思想是从输入数据中创建一个“短语
LZW 压缩算法
01-21 6748
LZW压缩算法介绍 转自：http://www.360doc.com/content/11/0217/14/2150347_93804935.shtml LZW是啥意思？懒子王！一听这名就知道这算法不是一般的懒子，要不怎么也称王呢。 　　懒子王压缩算法是一种新颖的压缩方法，由Lemple-Ziv-Welch 三人共同创造，用他们的名字命名。它采用了一种先进的字典压缩，将每
改进LZW压缩算法的一些想法（LZ77，双字典）
whycadi的专栏
01-25 8129
<br />  前几天用Python实现了一个LZW算法后，很自然的又想怎么样可以在不显著增加开销的前提下改进压缩率。在网上找了一些文章后，主要发现了以下的几种途径： 混合使用LZ77和LZ78。即在发现标记匹配结束后，不立即结束匹配，而是再在一个滑动窗口中寻找是否有更好的匹配，如果有就以{位置，匹配长度}组的形式写入输出流中，并把该字符串逐个增加为标记。在字典标记写满后，不立即清除字典，而是继续使用该字典，直到发现压缩率下降都到一定长度后再清除字典不清除全部字典，而是根据使用率清除部分字典<br />  
Lzw字典压缩（思路简单）
JThirteen的专栏
05-31 617
        Lzw字典压缩：     1978年，Ziv和Lempel开发了一种基于字典的被称为LZ78 的压缩算法，在LZ78中，字典是一个潜在的先前所见的短语的无限序列。后来由于自身限制，由Terry Welch在1984年提出的关于LZ78压缩算法的变种，他的编码器部署出单个字符，只是输出词典短语中的代号（或者说是代码）。        lzw的编码词典就像是一张转换表，用来存放每...
数据压缩第五次作业——LZW词典编码
Adore11的博客
05-08 2664
来谈谈词典编码
【数据压缩】第五次作业——LZW编解码算法实现与分析
weixin_47171941的博客
04-24 541
LZW编解码算法实现与分析
数据压缩课程作业——LZW压缩算法完整仿真代码和分析
博客
07-22 1577
文章目录前言一、算法描述二、算法流程2.1 编码过程[3]2.2解码过程学习目标：学习内容：学习时间：学习产出：总结 前言 关于数字压缩课程的作业记录 一、算法描述 1.1 算法特点 LZW压缩算法是一种无损数据压缩算法。在众多的压缩技术中，LZW算法是一种通用的、性能优良并得到广泛应用的压缩算法，它是一种完全可靠的算法，与其他算法相比，往往具有更高的压缩效率。LZW算法保留了LZ码的自适应功能，压缩比也大致相同，其显著特点是逻辑简单（典型的LZW算法处理1个字符不超过三个时钟周期）、硬件实现廉价、运算速
数据压缩（七）——LZW压缩编码解码
weixin_45430791的博客
04-23 596
对程序的具体分析我放在了程序的注释中。 LZW编码原理 LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新“词条”，然后用“代号”也就是码字表示这个“词条”。这样一来，对字符流的编码就变成了用码字去替换字符流，生成码字流，从而达到压缩数据的目的。LZW编码是围绕称为词典的转换表来完成的。LZW编码器通过管理这个词典完成输入与输出之间的转换。LZW编码器的输入是字符流，字符...
数据结构算法与应用-C++语言描述.rar
03-27
第5章 堆栈 161 5.1 抽象数据类型 161 5.2 派生类和继承 162 5.3 公式化描述 163 5.3.1 Stack的效率 164 5.3.2 自定义Stack 164 5.4 链表描述 166 5.5 应用 169 5.5.1 括号匹配 169 5.5.2 汉诺塔 170 ...
数据结构C++描述
03-15
第5章 堆栈 161 5.1 抽象数据类型 161 5.2 派生类和继承 162 5.3 公式化描述 163 5.3.1 Stack的效率 164 5.3.2 自定义Stack 164 5.4 链表描述 166 5.5 应用 169 5.5.1 括号匹配 169 5.5.2 汉诺塔 170 5.5.3 火车车厢...
数据结构算法与应用-C++语言描述
10-20
第5章 堆栈 161 5.1 抽象数据类型 161 5.2 派生类和继承 162 5.3 公式化描述 163 5.3.1 Stack的效率 164 5.3.2 自定义Stack 164 5.4 链表描述 166 5.5 应用 169 5.5.1 括号匹配 169 5.5.2 汉诺塔 170 5.5.3 火车车厢...
程序员实用算法——源码
07-15
第5章　排序 　5.1　排序的基本特征 　5.1.1　稳定性 　5.1.2　对哨兵的需求 　5.1.3　对链表进行排序的能力 　5.1.4　输入的阶的相关性 　5.1.5　对额外存储空间的需求 　5.1.6　内部排序技术与外部排序技术 　5.2...
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
第5章 线性表——数组描述 5.1 数据对象和数据结构 5.2 线性表数据结构 5.2.1 抽象数据类型linearList 5.2.2 抽象类linearList 5.3 数组描述 5.3.1 描述 5.3.2 变长一维数组 5.3.3 类arrayList 5.3.4 C++迭代器 ...
QT属性动画--设置样式属性(其他属性)
lizequan的博客
03-02 4983
这里写自定义目录标题故事背景遇到的问题解决过程最终方法感悟 故事背景   最近在制作一个按钮切换的动画特效中接触了属性动画这部分内容，并由此产生了一些思考。 遇到的问题 解决过程 最终方法 感悟 ...
Volatile的其他特性
我想月薪过万的博客
03-03 3656
2.1 volatile总体概览 在上一节中，我们已经研究完了volatile可以实现并发下共享变量的可见性，volatile除了保证可见性外，volatile还具备如下一些突出的特性： volatile的原子性问题：volatile不能保证原子性操作 禁止指令重排序：volatile可以防止指令重排序操作 2.2 volatile不保证原子性 2.3 代码测试 package Ls; /** * 目标：研究Volatile的原子性操作 * <p> * 基本观点：V.
【安卓基础】Android直接通过路径来操作其他应用的私有目录，可以吗？
m0_48179608的博客
03-02 7261
在上篇文章[【安卓基础】一文搞懂Android历代版本文件访问权限变化](https://blog.csdn.net/m0_48179608/article/details/122838494)我们对同一个应用的的文件访问权限做了比较。 那么不同应用之间文件访问又有什么限制呢？我们准备分二到三篇文件来阐述。 这篇文章，主要来看下不同系统版本下，我们直接通过路径来访问其它应用的**内部存储、外部存储私有目录**，看看能不能访问以及不同系统版本的区别。
Silane-PEG-NHS，SIL-PEG-NHS，可以用来修饰蛋白质、多肽以及其他活性基团，NHS-PEG-Silane
qq_39152602的博客
03-03 3307
英文名称：Silane-PEG-NHS 中文名称：硅烷-聚乙二醇-活性酯 分子量：1k，2k，3.4k，5k，10k，20k（可按需定制） 质量控制：95%+ 存储条件：-20°C，避光，避湿 用 途：仅供科研实验使用，不用于诊治 外观: 固体或粘性液体，取决于分子量 注意事项：取用一定要干燥，避免频繁的溶解和冻干 溶解性：溶于大部分有机溶剂，如：DCM、DMF、DMSO、THF等等。在水中有很好的溶解性 取用：现配现用，将包装从冰箱中取出，置于干燥器中缓慢升至室温，打开瓶盖，取用。取用.
lzw编码python作业
最新发布
09-09
根据引用和引用的内容，LZW编码是一种词典编码的算法，可以用C/C++/Python等语言实现。根据引用的内容，LZW编码的实验内容包括掌握...所以，lzw编码的Python作业将涉及实现LZW编码和解码的算法，并进行相应的实验分析。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值