LZW算法

① 求LZW算法源代码！！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>//用来计算压缩的时间
using namespace std;

//定义常数
const int MAX = 1000003;//最大code数，是一个素数，求模是速度比较快
const int ascii = 256; //ascii代码的数量
const int ByteSize = 8; //8个字节

struct Element//hash表中的元素
{
int key;
int code;
Element *next;
}*table[MAX];//hash表

int hashfunction(int key)//hash函数
{
return key%MAX;
}
void hashinit(void)//hash表初始化
{
memset(table,0,sizeof(table));
}
void hashinsert(Element element)//hash表的插入
{
int k = hashfunction(element.key);
if(table[k]!=NULL)
{
Element *e=table[k];
while(e->next!=NULL)
{
e=e->next;
}
e->next=new Element;
e=e->next;
e->key = element.key;
e->code = element.code;
e->next = NULL;
}
else
{
table[k]=new Element;
table[k]->key = element.key;
table[k]->code = element.code;
table[k]->next = NULL;
}
}
bool hashfind(int key,Element &element)//hash表的查找
{
int k = hashfunction(key);
if(table[k]!=NULL)
{
Element *e=table[k];
while(e!=NULL)
{
if(e->key == key)
{
element.key = e->key;
element.code = e->code;
return true;
}
e=e->next;
}
return false;
}
else
{
return false;
}
}
void compress(void)//压缩程序
{
//打开一个流供写入
FILE *fp;
fp = fopen("result.dat", "wb");

Element element;
int used;
char c;
int pcode, k;

for(int i=0;i<ascii;i++)
{
element.key = i;
element.code = i;
hashinsert(element);
}
used = ascii;

c = getchar();
pcode = c;
while((c = getchar()) != EOF)
{
k = (pcode << ByteSize) + c;
if(hashfind(k, element))
pcode = element.code;
else
{
//cout<<pcode<<' ';
fwrite(&pcode, sizeof(pcode), 1, fp);
element.code = used++;
element.key = (pcode << ByteSize) | c;
hashinsert(element);
pcode = c;
}
}
//cout<<pcode<<endl;
fwrite(&pcode, sizeof(pcode), 1, fp);

}
int main(void)
{
int t1,t2;

//欲压缩的文本文件
//freopen("input.txt","r",stdin);
freopen("book5.txt","r",stdin);

t1=time(NULL);
hashinit();
compress();
t2=time(NULL);

cout<<"Compress complete! See result.dat."<<endl;
cout<<endl<<"Total use "<<t2-t1<<" seconds."<<endl;
}

② LZW算法的LZW算法

LZW算法基于转换串表（字典）T，将输入字符串映射成定长（通常为12位）的码字。在12位4096种可能的代码中，256个代表单字符，剩下3840给出现的字符串。
LZW字典中的字符串具有前缀性，即 ωK∈T=>；ωT。
LZW算法流程：
步骤1： 开始时的词典包含所有可能的根(Root)，而当前前缀P是空的；步骤2： 当前字符(C) ：=字符流中的下一个字符；步骤3： 判断缀-符串P+C是否在词典中(1) 如果“是”：P ：= P+C // (用C扩展P) ；(2) 如果“否”① 把代表当前前缀P的码字输出到码字流;② 把缀-符串P+C添加到词典;③ 令P ：= C //(现在的P仅包含一个字符C);步骤4： 判断码字流中是否还有码字要译(1) 如果“是”，就返回到步骤2；(2) 如果“否”① 把代表当前前缀P的码字输出到码字流;② 结束。 具体解压步骤如下：
(1)译码开始时Dictionary包含所有的根。
(2)读入在编码数据流中的第一个码字 cW(它表示一个Root)。
(3)输出String.cW到字符数据流Charstream。
(4)使pW=cW 。
(5)读入编码数 据流 的下一个码字cW 。
(6)目前在字典中有String.cW吗?
YES：1)将String．cW输出给字符数据流；
2)使P=String.pW；
3)使C=String.cW的第一个字符；
4)将字符 串P+C添 加进Dictionray。
NO ：1)使P=String.pW ；
2)使C=String.pW的第一个字符；
3)将字符串P+C输出到字符数据流并将其添加进Dictionray(现在它与cW相一致)。
(7)在编码数据 流中还有Codeword吗?
YES：返回(4)继 续进行 译码 。
NO：结束译码 。

③ LZW算法的LZW算法简介

字符串和编码的对应关系是在压缩过程中动态生成的，并且隐含在压缩数据中，解压的时候根据表来进行恢复，算是一种无损压缩.
根据 Lempel-Ziv-Welch Encoding ，简称 LZW 的压缩算法，用任何一种语言来实现它.
LZW压缩算法 的基本概念：LZW压缩有三个重要的对象：数据流（CharStream）、编码流（CodeStream）和编译表（String Table）。在编码时，数据流是输入对象（文本文件的据序列），编码流就是输出对象（经过压缩运算的编码数据）；在解码时，编码流则是输入对象，数据流是输出对象；而编译表是在编码和解码时都须要用借助的对象。
字符（Character）：最基础的数据元素，在文本文件中就是一个字节，在光栅数据中就是一个像素的颜色在指定的颜色列表中的索引值；
字符串（String）：由几个连续的字符组成；
前缀（Prefix）：也是一个字符串，不过通常用在另一个字符的前面，而且它的长度可以为0；
根（Root）：一个长度的字符串；
编码（Code）：一个数字，按照固定长度（编码长度）从编码流中取出，编译表的映射值；图案：一个字符串，按不定长度从数据流中读出，映射到编译表条目.
LZW压缩算法 的基本原理：提取原始文本文件数据中的不同字符，基于这些字符创建一个编译表，然后用编译表中的字符的索引来替代原始文本文件数据中的相应字符，减少原始数据大小。看起来和调色板图象的实现原理差不多，但是应该注意到的是，我们这里的编译表不是事先创建好的，而是根据原始文件数据动态创建的，解码时还要从已编码的数据中还原出原来的编译表.

④ LZW算法问题

LZW算法全名叫做Lempel-Ziv-Welch Encoding，是一种数据压缩算法，它是有专利的，不过现今大部分专利都己经过期。它可以对文本进行简单的压缩，压缩比对于一般场合还是可以适用的，另外使用的比较多的就是GIF图像了。
LZW算法中有几个比较重要的概念：字符，字符串，编码表。它把数据流看成一个字符序列，并将字符序列组织成一系列的字符串，并给每个字符串一个编码，最后存储的就是字符串的编码，这样就节省了空间。如将ababba表示为编码1532，而1523用12bit就可以表示出来，比原来5*8bit就节省了不少空间。LZW的编码表是动态创建的，并且通过编码后的数据流可以恢复出与编码时同样的编码表，这样在数据存储与传输的时候就不需要保存原始的编码表，这也是与一些在编码之前就有固定的编码表的算法有着巨大的区别。
1.编码过程：
LZW是一个固长编码的算法的，即对于每一个字符或字符串的编码都是等长的。为了说明的方便，我决定用16bit作为编码，前255作为字符编码，256，257另作它用，这将在3中进行说明。所以字符串的编码将从258开始。
编码的整个过程如下：
1. 初始化编码表，编码起始号，并置当前字符串为空；
2. 读入一个字符，如果为EOF，输出当前字符串，并结束，否则进入3；
3. 将新读入的字符与当前字符串组成新的字符串，如果新的字符串在编码表中出现，则继续进行2，否则进入4；
4. 将新的字符串加入到编码表中，分配编号，设当前字符串的长度为N，输入新字符串的N-1长度前缀的编码，并将当前字符串置为当前字符串的一个长度为1的后缀，再执行2。

2.解码过程：
对于解码，唯一需要知道的就是编码的长度了，每次从编码流中读取相应bit的长度，就形成一个编码，再通过该编码从编码表中找出相对应的串输出即可。由于没有存储编码时对应的编码表，在译码时需要同时构造编码表。
译码过程如下：
1. 初始化编码表，并置前一个编码为空；
2. 取一个编码，如果编码为结束，则结束。否则进行3；
3. 输出编码所代表的字符串，如果前一个编码不为空，将前一个编码的字符串与当前字符串的第一个字符作为新的串加入编码表中，置前一个编码为当前编码，并执行2。

⑤ LZW算法解题

拆

⑥ 谁能提供个lzw压缩算法的c语言完整实现

程序由五个模块组成。(1) lzw.h 定义了一些基本的数据结构，常量，还有变量的初始化等。#ifndef __LZW_H__
#define __LZW_H__
//------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <memory.h>
//------------------------------------------------------------------------------
#define LZW_BASE 0x102// The code base
#define CODE_LEN 12 // Max code length
#define TABLE_LEN 4099 // It must be prime number and bigger than 2^CODE_LEN=4096.
// Such as 5051 is also ok.
#define BUFFERSIZE 1024
//------------------------------------------------------------------------------
typedef struct
{
HANDLE h_sour; // Source file handle.
HANDLE h_dest; // Destination file handle.

HANDLE h_suffix; // Suffix table handle.
HANDLE h_prefix; // Prefix table handle.
HANDLE h_code; // Code table handle.

LPWORD lp_prefix; // Prefix table head pointer.
LPBYTE lp_suffix; // Suffix table head pointer.
LPWORD lp_code; // Code table head pointer. WORD code;
WORD prefix;
BYTE suffix; BYTE cur_code_len; // Current code length.[ used in Dynamic-Code-Length mode ]}LZW_DATA,*PLZW_DATA;
typedef struct
{
WORD top;
WORD index; LPBYTE lp_buffer;
HANDLE h_buffer;

BYTE by_left;
DWORD dw_buffer; BOOL end_flag;}BUFFER_DATA,*PBUFFER_DATA;
typedef struct //Stack used in decode
{
WORD index;
HANDLE h_stack;
LPBYTE lp_stack;}STACK_DATA,*PSTACK_DATA;
//------------------------------------------------------------------------------
VOID stack_create( PSTACK_DATA stack )
{
stack->h_stack = GlobalAlloc( GHND , TABLE_LEN*sizeof(BYTE) );
stack->lp_stack = GlobalLock( stack->h_stack );
stack->index = 0;
}
//------------------------------------------------------------------------------
VOID stack_destory( PSTACK_DATA stack )
{
GlobalUnlock( stack->h_stack );
GlobalFree ( stack->h_stack );
}
//------------------------------------------------------------------------------
VOID buffer_create( PBUFFER_DATA buffer )
{
buffer->h_buffer = GlobalAlloc( GHND, BUFFERSIZE*sizeof(BYTE) );
buffer->lp_buffer = GlobalLock( buffer->h_buffer );
buffer->top = 0;
buffer->index = 0;
buffer->by_left = 0;
buffer->dw_buffer = 0;
buffer->end_flag = FALSE;
}
//------------------------------------------------------------------------------
VOID buffer_destory( PBUFFER_DATA buffer )
{
GlobalUnlock( buffer->h_buffer );
GlobalFree ( buffer->h_buffer );
}
//------------------------------------------------------------------------------
VOID re_init_lzw( PLZW_DATA lzw ) //When code table reached its top it should
{ //be reinitialized.
memset( lzw->lp_code, 0xFFFF, TABLE_LEN*sizeof(WORD) );
lzw->code = LZW_BASE;
lzw->cur_code_len = 9;
}
//------------------------------------------------------------------------------
VOID lzw_create(PLZW_DATA lzw, HANDLE h_sour, HANDLE h_dest)
{
WORD i;
lzw->h_code = GlobalAlloc( GHND, TABLE_LEN*sizeof(WORD) );
lzw->h_prefix = GlobalAlloc( GHND, TABLE_LEN*sizeof(WORD) );
lzw->h_suffix = GlobalAlloc( GHND, TABLE_LEN*sizeof(BYTE) );
lzw->lp_code = GlobalLock( lzw->h_code );
lzw->lp_prefix = GlobalLock( lzw->h_prefix );
lzw->lp_suffix = GlobalLock( lzw->h_suffix );
lzw->code = LZW_BASE;
lzw->cur_code_len = 9;
lzw->h_sour = h_sour;
lzw->h_dest = h_dest;
memset( lzw->lp_code, 0xFFFF, TABLE_LEN*sizeof(WORD) );}
//------------------------------------------------------------------------------
VOID lzw_destory(PLZW_DATA lzw)
{
GlobalUnlock( lzw->h_code );
GlobalUnlock( lzw->h_prefix );
GlobalUnlock( lzw->h_suffix );GlobalFree( lzw->h_code );
GlobalFree( lzw->h_prefix );
GlobalFree( lzw->h_suffix );
}
//------------------------------------------------------------------------------
#endif(2) fileio.h 定义了一些文件操作#ifndef __FILEIO_H__
#define __FILEIO_H__
//------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
//------------------------------------------------------------------------------
HANDLE file_handle(CHAR* file_name)
{
HANDLE h_file;
h_file = CreateFile(file_name,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
0,
NULL
);
return h_file;
}
//------------------------------------------------------------------------------
WORD load_buffer(HANDLE h_sour, PBUFFER_DATA buffer) // Load file to buffer
{
DWORD ret;
ReadFile(h_sour,buffer->lp_buffer,BUFFERSIZE,&ret,NULL);
buffer->index = 0;
buffer->top = (WORD)ret;
return (WORD)ret;
}
//------------------------------------------------------------------------------
WORD empty_buffer( PLZW_DATA lzw, PBUFFER_DATA buffer)// Output buffer to file
{

DWORD ret;
if(buffer->end_flag) // The flag mark the end of decode
{
if( buffer->by_left )
{
buffer->lp_buffer[ buffer->index++ ] = (BYTE)( buffer->dw_buffer >> 32-buffer->by_left )<<(8-buffer->by_left);
}
}
WriteFile(lzw->h_dest, buffer->lp_buffer,buffer->index,&ret,NULL);
buffer->index = 0;
buffer->top = ret;
return (WORD)ret;
}
//------------------------------------------------------------------------------
#endif

⑦ 关于LZW的算法硬件实现

xzxzcvxzcvxzcxzcv

⑧ lzw和lz78算法的核心思想是什么他们之间有什么差别

LZ78是每读入一个字符的同时，将其编入自己的字典，然后，再读入字符的同时，则在已有的字典里查找，没有的话该字符就在新编入辞典。如此循环。
LZW是先建立了ASCII码的字典，这样就事先花费了8个字节（256个ASCII码）的存储空间，然后再像LZ78一样读入字符，没有的再进行编入字典，如此循环。

⑨ LZW算法的LZW压缩的特点

LZW码能有效利用字符出现频率冗余度进行压缩，且字典是自适应生成的，但通常不能有效地利用位置冗余度。
具体特点如下：
l)LZW压缩技术对于可预测性不大的数据具有较好的处理效果，常用于TIF格式的图像压缩，其平均压缩比在2：1以上，最高压缩比可达到3：1。
2）对于数据流中连续重复出现的字节和字串，LZW压缩技术具有很高的压缩比。
3）除了用于图像数据处理以外，LZW压缩技术还被用于文本程序等数据压缩领域。
4)LZW压缩技术有很多变体，例如常见的ARC、RKARC、PKZIP高效压缩程序。
5）对于任意宽度和像素位长度的图像，都具有稳定的压缩过程。压缩和解压缩速度较快。
6）对机器硬件条件要求不高，在 Intel 80386的计算机上即可进行压缩和解压缩。