LWZ openws

/************************************************************************/
/* File Name: LZW.cpp
* @Function: Lossless Compression
@Author: Sophia Zhang
@Create Time: 2012-9-19 10:00
@Last Modify: 2012-9-19 11:10
*/
/************************************************************************/


#include"iostream"
#include "map"
#include "string"
#include "iterator"
#include "vector"
using namespace std;


/************************************************************************/
/* Compress Module
* input:
str - the string need to be compressed
result - compress result
*/
/************************************************************************/
template<typename TypeIterator>
TypeIterator Compress(string str, TypeIterator result)
{
//Build the dictionary
map<string,int>dictionary;
int Dictsize=256;
for(int i=0;i<Dictsize;i++)
dictionary[string(1,i)]=i;


char z;
string S;


for(string::const_iterator it = str.begin(); it!=str.end(); it++)
{
z = *it;


if(dictionary.count(S+z))//can find S
{S+=z;
cout<<S<<endl;}
else//S is not in dictionary D
{
*result++ = dictionary[S];//output pointer (S,D)
dictionary[S+z] = Dictsize++; //add to dictionary
cout<<S+z<<"\t"<<Dictsize-1<<"\t"<<S<<endl;
S = z;
}
}
if(!S.empty())
*result++ = dictionary[S];


return result;
}


/************************************************************************/
/* Decompress Module
* input:
TypeIterator result - compression result, to be decompressed
*/
/************************************************************************/
template<typename TypeIterator>
string Decompress(TypeIterator result)
{   cout<<"****************"<<endl;
map<int,string>inv_dictionary;
int Dictsize=256;
for(int i=0;i<Dictsize;i++)
inv_dictionary[i] = string(1,i);


char z;
string S;
string entry;
string res;
Dictsize--;//because the first "Dictsize++" make no sense, it has only one char in [0,255]


for(vector<int>::iterator it = result.begin(); it!=result.end(); it++)
{
int k = *it;
if(inv_dictionary.count(k))
entry = inv_dictionary[k];
else if(k==Dictsize)
entry = S+ S[0];
else
throw "Bad compression code";


res += entry;


inv_dictionary[Dictsize++] = S + entry[0];
cout<<entry<<"\t"<<Dictsize-1<<"\t"<<inv_dictionary[Dictsize-1]<<endl;
S = entry;
}
return res;
}




int main()
{
typedef vector<int> TypeIterator;
TypeIterator compress_res;
string S = "abc";
Compress(S,std::back_inserter(compress_res));
// copy(compress_res.begin(),compress_res.end(),std::ostream_iterator<int>(std::cout,","));
// std::cout<<std::endl;


//output the compressed result
for( TypeIterator::iterator it= compress_res.begin(); it!=compress_res.end(); it++)
cout<<(*it)<<endl;


//decompress the compressed result
string decompress = Decompress(compress_res);
cout<<decompress<<endl;
}