关于HuffmanCoding的简单分析

1.what's problem we faced?

/**

* Q: what's problem we faced?

*

* A: Data compression is still a problem, even now. we want to compress

* the space of data. This desire is more and more stronger when we

* need to deal with some operation about data transmission. Before

* we start this article, it may be helpful if you try to provide a valid way

* to compress data . I tried, but failed obviously. That why I write this

* article. ^_^

*/

2. How can I solve it?

/**

* Q: How can I solve it?

*

* A: Where have problem is where have an answer, although it not always

* the best one. In 1951, a algorithm was introduced by David A. Huffman.

* It is different from the normal code and is a variable length code, which

* have different length of code for different symbol. Now, there are two

* problems:

*

* No.1: is variable length code possible? How can we know the length

* of current symbol?

*

* The answer is prefix code. Think about this, a tree like following:

*

*

* O

* 1 / \ 0

* O O

* 1 / \ 0 c

* O O

* a b

*

* This is a simple binary tree. There are three leaf node: a, b ,and c.we

* label all of left branch as 1, and all of right branch as 0. So if we want

* to arrive the leaf node a, the path is 11. In a similar way, we can get

* all of nodes:

* a : 11

* b : 10

* c : 0

*

* By accident, we get a variable length code.

*

*

* No.2: How can we use variable length code to compress a series of symbol?

*

* Now that we have a ability about variable length code. Some funny thing

* will happen. Image this, In a data, which consist of a series of symbols,

* some of symbols have occur at high proportion. some of symbols has occur

* at low proportion. If we use some shorter code to indicate those symbols

* which have a high proportion, the space of data will smaller than ever.

* That is what we want.

*

* Now, we have been know that we could compress a data by use variable length

* code. However, the next problem is what kind of variable length code is what we

* want. what kind of code is optimal ?

*/

3. What is HuffmanCoding ?

/**

* Q: What is HuffmanCoding ?

*

* A:Now,the problem is how can I create a optimal tree ? Do you have any idea?

* Huffman was introduced a algorithm. It is looks like greedy algorithm. It is may

* be simple, but the result is valid( this will be demonstrated below). The simplest

* construction algorithm use a priority queue where the node with lowest probability

* is given highest priority, the steps as following:

*

* 1. create a leaf node for each symbol, and add it to the priority queue.

* 2. while there is more than one node in the queue:

* 1. remove two nodes that have the highest priority.

* 2. create a new node as the parent node of the two nodes above. the

* probability of this one is equal to the sum of the two nodes' probabilities.

* 3. add the new node to the queue.

* 3. the remaining node is the root of this tree. Read it's code as we do above.

*

*/

4. is it optimal ?

/**

* Q: is it optimal ?

*

* A: Hard to say. I haven't a valid method to measure this. About this issue, it is necessary to hear

* about other people's advice. I believe there must be some exciting advice. By the way, this article

* is just talk about compress of independent symbol, another important issue is about related symbol.

* That maybe a serious problem.

*

*/

5. source code

/**
*    Here is an simple example
*/

#include <stdio.h>
#include <iostream>

/**
*    In a Huffman tree, some of nodes is valid symbol, and other is a combine node, which
*    haven't a valid symbol. we need to label it in our nodes.
*/
enum ELEM_TYPE {
ET_VALID,
ET_INVALID,
ET_MAX,
};

typedef int    INDEX;

/**
*    this is a container, we push all of element to it, and pop element by a priority. It is
*    a class template since we don't know the type of data element.
*/
template <class ELEM>
class Container {
public:
Container( int capacity);
~Container( );
/*
*    push a element to this container.
*/
bool push( ELEM item);
/*
*    pop a element from this container, the smallest one have the most priority.
*    Of course, the element must have provide a reload function for operator '<'.
*/
bool pop( ELEM &item );

private:
bool _find_idle( INDEX &num);
bool _set_elem( INDEX num, ELEM &elem);
bool _get_elem( INDEX num, ELEM &elem);

ELEM                *ele;
ELEM_TYPE    *stat;
int                        cap;
};

template <class ELEM>
Container<ELEM>::Container(  int capacity)
{
this->ele = new ELEM[capacity] ;
this->stat = new ELEM_TYPE[capacity];

int        i;
for( i=0; i<capacity; i++)
this->stat[i] = ET_INVALID;

this->cap = capacity ;
}

template <class ELEM>
Container<ELEM>::~Container(  )
{
if( this->ele!=NULL )
delete []this->ele;

if( this->stat!=NULL )
delete []this->stat;

this->cap = 0;
}

template <class ELEM>
bool Container<ELEM>::push( ELEM item)
{
INDEX        num = -1;

if( (!this->_find_idle( num))
||(!this->_set_elem( num, item)))
return false;

return true;
}

template <class ELEM>
bool Container<ELEM>::pop( ELEM &item )
{
INDEX    i = 0;
INDEX    Min;

/*
*    find the first valid element.
*/
while( (this->stat[i]!=ET_VALID)
&&( i<this->cap))
i++;

for( Min = i ; i<this->cap; i++)
{
if(  ( this->stat[i]==ET_VALID)
&&( this->ele[i]<this->ele[Min]))
{
Min = i;
}
}

return this->_get_elem( Min, item);
}

template <class ELEM>
bool Container<ELEM>::_find_idle( INDEX &num)
{
INDEX        i;
for( i=0; i<this->cap; i++)
{
if( this->stat[i]==ET_INVALID )
{
num = i;
return true;
}
}

return false;
}

template <class ELEM>
bool Container<ELEM>::_set_elem( INDEX num, ELEM &elem)
{
if( (num>=this->cap)
||(num<0) )
return false;

this->stat[num] = ET_VALID;
this->ele[num] = elem;

return true;
}

template <class ELEM>
bool Container<ELEM>::_get_elem( INDEX num, ELEM &elem)
{
if( (num<0)
||(num>=this->cap))
return false;

this->stat[num] = ET_INVALID;
elem =  this->ele[num];

return true;
}

/**
*    define a type of symbol. It will be used to record all information about a symbol.
*/
typedef char SYMINDEX;
typedef int SYMFRE;

class Symbol {
public:
/*
*    In the Huffman tree, we need to compute the sum of two child symbol.
*    For convenience,build a reload function is necessary.
*/
Symbol operator + ( Symbol &s);
SYMINDEX        sym;
SYMFRE            freq;
};

Symbol Symbol::operator +( Symbol &s)
{
Symbol        ret;
ret.sym = '\0';
ret.freq = this->freq + s.freq;
return ret;
}

/**
*    define a node of binary tree. It will be used to create a Huffman tree.
*/
class HTreeNode {
public:
/*
*    In the container, we need compare two nodes. So this node must
*    provide a reload function about '<'.
*/
bool operator< ( HTreeNode &n);

HTreeNode        *lchild;
HTreeNode        *rchild;
Symbol                sym;
};

bool HTreeNode::operator < ( HTreeNode &n)
{

return this->sym.freq<n.sym.freq?

true: false;
}

/**
*    This is the core structure. It will build a Huffman coding based on our input symbol.
*/
class HuffmanCoding {
public:
HuffmanCoding( );
~HuffmanCoding( );
bool Set( Symbol s[], int num);
bool Work( void);

private:
/*
*    create a Huffman tree.
*/
bool CreateTree(Symbol s[], int num );
bool DestroyTree( );
/*
*    read Huffman coding from a Huffman tree.
*/
bool ReadCoding( );
bool TravelTree( HTreeNode *parent, char *buf, INDEX cur);

Symbol                *sym ;
int                        sym_num ;
HTreeNode        *root ;
};

HuffmanCoding::HuffmanCoding( )
{
this->sym = NULL;
this->sym_num = 0;
this->root = NULL;
}

HuffmanCoding::~HuffmanCoding( )
{
if( this->sym!=NULL)
delete []this->sym;

this->sym_num = 0;
this->DestroyTree( );
}

/**
*    receive data from outside. Actually, this function is not necessary.But for make the
*    algorithm looks like more concise,maybe this function is  necessary.
*/
bool HuffmanCoding::Set( Symbol s [ ], int num)
{
this->DestroyTree( );

this->sym = new Symbol[num];
for( int i=0; i<num; i++)
this->sym[i] = s[i];

if( NULL!=this->sym)
{
this->sym_num = num;
return true;
}
else
{
this->sym_num = 0;
return false;
}
}
/**
*    The core function. In this function, we create a Huffman tree , then read it.
*/
bool HuffmanCoding::Work( void)
{

//Create a Huffman tree
if( !this->CreateTree( this->sym, this->sym_num))
return false;
//read Huffman coding
if( !this->ReadCoding( ))
return false;

return true;
}

bool HuffmanCoding::CreateTree( Symbol s[], int num)
{
/*
*    create a priority tank. It always pop the element of the highest priority in the tank.
*/
Container<HTreeNode>	tank(num);
for( int i=0; i<this->sym_num; i++)
{
HTreeNode        node;
node.lchild = NULL;
node.rchild = NULL;
node.sym = s[i];
tank.push( node);
}
/*
*    always pop two nodes, if fail, that's means there is only one node remain and it
*    is the root node of this Huffman tree.
*/
HTreeNode        node1;
HTreeNode        node2;
while(  tank.pop( node1)
&& tank.pop( node2) )
{
HTreeNode        parent;
parent.lchild = new HTreeNode;
parent.rchild = new HTreeNode;
*parent.lchild = node1;
*parent.rchild = node2;
parent.sym = node1.sym + node2.sym;
/*
*    push new node to the tank.
*/
tank.push( parent);
}

this->root = new HTreeNode(node1);

return true;
}

bool HuffmanCoding::DestroyTree( )
{

return false;
}

bool HuffmanCoding::ReadCoding( )
{
char        *code;
code = new char[this->sym_num + 1];
/*
*    travel the Huffman tree and print the code of all valid symbols.
*/
this->TravelTree( this->root, code, 0);

delete []code;

return true;
}

#define        LCHAR    '1'
#define        RCHAR    '0'

bool HuffmanCoding::TravelTree( HTreeNode *parent, char *buf, INDEX cur)
{
buf[cur] = '\0';
if( (parent->lchild==NULL)
&&(parent->rchild==NULL) )
{//end node
printf("[ %c] : %s\n", parent->sym.sym, buf);
}

if( parent->lchild!=NULL )
{
buf[cur] = LCHAR;
this->TravelTree( parent->lchild, buf, cur + 1);
}

if( parent->rchild!=NULL )
{
buf[cur] = RCHAR;
this->TravelTree( parent->rchild, buf, cur + 1);
}

return true;
}

static Symbol	sArr[ ] = {
{ '0', 0},
{ '1', 1},
{ '2', 2},
{ '3', 3},
{ '4', 4},
{ '5', 5},
{ '6', 6},
{ '7', 7},
{ '8', 8},
{ '9', 9},
};

int main()
{
HuffmanCoding    hcoding;
hcoding.Set( sArr, 10);
hcoding.Work( );

return 0;
}