关于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<
c109
;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;
}