huffman的实现

/*

   on: Lossless Compression 

            @Author: JackyLau 

            @Create Time: 2012-9-26 10:40 

            @Last Modify: 2012-9-26 12:10 

    */  

    /************************************************************************/  

      

    #include"iostream"  

    #include "queue"  

    #include "map"  

    #include "string"  

    #include "iterator"  

    #include "vector"  

    #include "algorithm"  

    using namespace std;  

      

    #define NChar 8 //suppose use 8 bits to describe all symbols  

    #define Nsymbols 1<<NChar //can describe 256 symbols totally (include a-z, A-Z)  

    typedef vector<bool> Huff_code;//8 bit code of one char  

    map<char,Huff_code> Huff_Dic; //huffman coding dictionary  

      

    /************************************************************************/  

    /* Tree Class elements: 

    *2 child trees 

    *character and frequency of current node 

    */  

    /************************************************************************/  

    class HTree  

    {  

    public :  

        HTree* left;  

        HTree* right;  

        char ch;  

        int weight;  

      

        HTree(){left = right = NULL; weight=0;ch ='\0';}  

        HTree(HTree* l,HTree* r,int w,char c){left = l; right = r;  weight=w;   ch=c;}  

        ~HTree(){delete left; delete right;}  

        bool Isleaf(){return !left && !right; }  

    };  

      

    /************************************************************************/  

    /* prepare for pointer sorting*/  

    /*because we cannot use overloading in class HTree directly*/  

    /************************************************************************/  

    class Compare_tree  

    {  

    public:  

        bool operator () (HTree* t1, HTree* t2)  

        {  

            return t1->weight> t2->weight;  

        }  

    };  

      

    /************************************************************************/  

    /* use priority queue to build huffman tree*/  

    /************************************************************************/  

    HTree* BuildTree(int *frequency)  

    {  

        priority_queue<HTree*,vector<HTree*>,Compare_tree> QTree;  

      

        //1st level add characters  

        for (int i=0;i<Nsymbols;i++)  

        {  

            if(frequency[i])  

                QTree.push(new HTree(NULL,NULL,frequency[i],(char)i));            

        }  

      

        //build  

        while (QTree.size()>1)  

        {  

            HTree* lc  = QTree.top();  

            QTree.pop();  

            HTree* rc = QTree.top();  

            QTree.pop();  

      

            HTree* parent = new HTree(lc,rc,lc->weight+rc->weight,(char)256);  

            QTree.push(parent);  

        }  

        //return tree root  

        return QTree.top();  

    }  

      

    /************************************************************************/  

    /* Give Huffman Coding to the Huffman Tree*/  

    /************************************************************************/  

    void Huffman_Coding(HTree* root, Huff_code& curcode)  

    {  

        if(root->Isleaf())  

        {  

            Huff_Dic[root->ch] = curcode;  

            return;  

        }  

        Huff_code lcode = curcode;  

        Huff_code rcode = curcode;  

        lcode.push_back(false);  

        rcode.push_back(true);  

      

        Huffman_Coding(root->left,lcode);  

        Huffman_Coding(root->right,rcode);  

    }  

      

    int main()  

    {  

        int freq[Nsymbols] = {0};  

        char *str = "this is the string need to be compressed";  

      

        //statistic character frequency  

        while (*str!='\0')  

            freq[*str++]++;  

      

        //build tree  

        HTree* r = BuildTree(freq);  

        Huff_code nullcode;  

        nullcode.clear();  

        Huffman_Coding(r,nullcode);  

      

        for(map<char,Huff_code>::iterator it = Huff_Dic.begin(); it != Huff_Dic.end(); it++)  

        {  

            cout<<(*it).first<<'\t';  

            std::copy(it->second.begin(),it->second.end(),std::ostream_iterator<bool>(cout));  

            cout<<endl;  

        }

}