lzw编码的实验

qq_46294984

于 2022-07-04 21:10:44 发布

阅读量56

点赞数

分类专栏：数压作业文章标签：数据分析

本文链接：https://blog.csdn.net/qq_46294984/article/details/125607599

版权

数压作业专栏收录该内容

9 篇文章 0 订阅

订阅专栏

概述

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。

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）如果”否”，结束。

LZW解码算法开始时，译码词典和编码词典相同，包含所有可能的前缀根。

LZW解码算法首先初始化词典，然后顺序从压缩文件中读入码字并按照上述算法执行解码，最后将解得的字符串输出至文件中。
图解如下：
在这里插入图片描述

代码

头文件bitio.h

#pragma once
#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.cpp

#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

#include <stdlib.h>
#include <stdio.h>
#include "bitio.h"
#include <iostream>
using namespace std;
#define MAX_CODE 256*256     //规定词典数目上限

//构造词典树
struct 
{
	int suffix;    //当前字符的尾缀字符
	int parent, firstchild, nextsibling;  //当前节点对应的母节点、第一个孩子节点、下一个兄弟节点
} dictionary[MAX_CODE + 1];
int next_code;
int d_stack[MAX_CODE]; // 存储解码后的短语

#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) 
{
	for (int 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;   //下一个词条的编码
}

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) 
{  //读入的新字符character（尾缀）和旧词条string_code（前缀）
	int s1, s2;
	//如果string_code=-1，说明是单个字符，直接返回即可
	if (string_code < 0)  return;
	//初始化下一个词条信息
	dictionary[next_code].suffix = character;
	dictionary[next_code].parent = string_code;
	dictionary[next_code].firstchild = -1;
	dictionary[next_code].nextsibling = -1;
	//找到链接的前缀
	s1 = dictionary[string_code].firstchild;
	if (s1 < 0) 
	{
		dictionary[string_code].firstchild = next_code;
	}
	else 
	{
		s2 = s1;
		while (dictionary[s2].nextsibling > -1) 
		{
			s2 = dictionary[s2].nextsibling;
		}
		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);   //调用BitsOutput函数
	InitDictionary();    //初始化词典
	string_code = -1;    //初始值赋值为-1，方便在第一次判断的时候判断读取是否为单个字符
	while (EOF != (character = fgetc(fp))) 
	{
		//fgetc是从文件中读取一个字符，EOF是文件结束的标志，从文件中读取字符，直到读到结束标志
		//fgetc是从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。
		index = InDictionary(character, string_code);    //判断当前字符是否在词典中，返回字符在词典中的index，如果不在则返回-1
		if (0 <= index) //P+C已经在词典中了
		{	
			string_code = index;  //P<-P+C;
		}
		else 
		{
			output(bf, string_code);   //重定义的输出，向编码后的文件中输出旧词条
			if (MAX_CODE > next_code) {	// 如果词典还有空间
				AddToDictionary(character, string_code);    //将P+C添加到词典中
			}
			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) 
	{   //进入循环，直到所有码字完成解码
		new_code = input(bf);    //重定义的输入，从压缩后的文件中读入码字
		if (new_code >= next_code) 
		{   //除第一次外，每次都要判断新的字符是否在词典中
									   //如果新的码字比当前词典中最后一个码字要大，就说明新的码字已经不在词典中了
			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;
}

指令行：

E t1.txt t1d.dat
对 t1.txt编码，输出 t1d.dat
D t1d.dat t1r.txt
对t1d.dat解码，输出t1r.txt

结果

输出词典：
在这里插入图片描述
源文件，编码文件，解码文件：

结果发现编码之后文件更大了，不如不编。。。

推测是因为源文件太小，加大容量：

这样就能看出编码的优势了。

qq_46294984

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
lzw编码的实验

LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新 “ 词条 ” ，然后用 “ 代号 ” 也就是码字表示这个 “ 词条 ” 。这样一来，对字符流的编码就变成了用码字去替换字符流，生成码字流，从而达到压缩数据的目的。LZW编码是围绕称为词典的转换表来完成的， LZW 编码器通过管理这个词典完成输入与输出之间的转换。其输入是字符流，字符流可以是用 8 位 ASCII 字符组成的字符串，而输出是用 n 位 ( 例如 12 位 ) 表示的码字流。编码步骤1：将词典初始化为包含所有可能的单字符，当
复制链接

扫一扫