完美huffman编码压缩解压缩实现（实现256个ASCII字符）

//<HuffmanGKM.h>
 #include "stdafx.h"
 #include <string>

 using std::string;

 const int CHNUM=256;    //字符数
 const int PLUS=128;        //字符下标偏移量
 struct WeightGkm        //字符频度结构，包含频度和字符值
 {
     unsigned long w;
     char c;
 };
 typedef struct HTNode    //huffman树结构
 {
     int count;
     WeightGkm w;
     string code;
     HTNode * lchild;
     HTNode * rchild;
 }HTNode,*HTree;

 class HuffmanGKM
 {
 private:
     HTree T;    //构造Huffman树；
     string huffCode[CHNUM];        //256个字符的Huffman编码；

     unsigned long weight[CHNUM];    //256个可打印字符的频度（或叫权重）
     unsigned long long file_size;    //原始文件字符总数，即文件长度

     string original_file;    //原始文件路径
     string compress_file;    //压缩文件存储路径
     string decompress_file;    //解压缩文件存储路径

     void QuickSortHT( HTree ht[], int left, int right);        //快速排序
     int Partition( HTree ht[], int left, int right);        //快速排序中的“分半”
     void SelectInsert( HTree ht[], HTree t, int left ,int right);    //按序插入
 public:

     HuffmanGKM( string originalFile , string compressFile, string decompressFile);

     int ReadFile();        //读取原文件，并记录每个字符频度
     int BuildHuffTree();    //根据频度建立字符的Huffman树
     int CreateHuffCode();    //根据huffman树得到huffman编码
     int CompressFile();        //用新编码转换原文件
     int DecompressFile();    //根据huffman树解压缩huffman编码的压缩文件

     ~HuffmanGKM();        //析构函数，释放堆空间
 };

//<HuffmanGKM.cpp>
 #include "stdafx.h"
 #include <iostream>
 #include <fstream>
 #include "HuffmanGKM.h"
 #include <string>
 #include <bitset>

 using std::bitset;
 using std::string;
 using std::ifstream;
 using std::ofstream;
 using std::cout;
 using std::endl;
 using std::ios;

 HuffmanGKM::HuffmanGKM( string originalFile , string compressFile, string decompressFile)
 {
     for(int i=0;i<CHNUM;i++)
         weight[i]=0;

     file_size=0;
     original_file=originalFile;
     compress_file=compressFile;
     decompress_file=decompressFile;

 }

 int HuffmanGKM::ReadFile()
 {
     ifstream read;
     read.open (original_file);
     if(read.fail())
     {
         cout<<"The original file open failed when read file!!";
         return 0;
     }

     char next;
     read.get(next);
     while(!read.eof())//统计频度。
     {
         weight[next+PLUS]++;
         read.get(next);
         file_size++;
     }

     read.close ();
     return 0;
 }

 void HuffmanGKM::QuickSortHT ( HTree htt[], int left, int right )
 {
     int pivot;
     if( left < right )  // 肯定为真的条件
     {
         pivot = Partition ( htt, left, right );
         QuickSortHT( htt, left, pivot-1 );
         QuickSortHT( htt, pivot+1, right );
     }

 }
 //快速排序的patition算法
 int HuffmanGKM::Partition ( HTree htt[ ], int left, int right )  //这是左大右小的排序
 {
     HTree HTPivot = htt[left];　　　　　　//这叫“虚左以待”

     while( left < right )
     {
         while( right > left && htt[ right]->w.w >= HTPivot->w.w )
             right--;
         htt[ left ] = htt[ right ];

         while( left < right && htt[ left ]->w.w <= HTPivot->w.w )
             left++;
         htt[ right ] = htt[ left ];
     }

     htt[ left ] = HTPivot;

     return left;  //最后left=right，所以返回哪个都一样

 }

 void HuffmanGKM:: SelectInsert( HTree htt[], HTree p, int left ,int right)//left是第一个要比较的元素
 {
     for( ;left<=right;left++)
     {
         if( p->w.w > htt[left]->w.w )
             htt[left-1]=htt[left];//左移小元素。
         else
             break;
     }
     htt[left-1]=p;
 }

 int HuffmanGKM::BuildHuffTree()
 {
     int left=0,right=CHNUM-1;
     HTree ht[CHNUM];    //树结点的排序数组

     for( int i=0; i<CHNUM;i++)    //初始化huffman树结点
     {
         ht[i]= new HTNode ;
         ht[i]->w.w=weight[i];    //字符频度
         ht[i]->count=1;            //树中结点个数,仅做测试用。
         ht[i]->w.c=i-PLUS;        //字符值
         ht[i]->lchild =0;
         ht[i]->rchild=0;
     }

     QuickSortHT( ht ,left , right );    //先把各结点字符按频度升序排序。

     HTree parent;
     while(left<right)    //建树的过程很简单。
     {
         ht[left]->code ="1";
         ht[left+1]->code ="0";
         parent=new HTNode;
         parent->lchild =ht[left];
         parent->rchild =ht[left+1];

         parent->w.c=0;
         parent->w.w=parent->lchild ->w.w+parent->rchild ->w.w ;
         parent->count=parent->lchild ->count + parent->rchild->count + 1;
         SelectInsert( ht,parent,left+2,right);
         left++;
     }
     T=parent;    //T为建好的huffman树。
     return 0;
 }

 int HuffmanGKM::CreateHuffCode ()
 {
     //非递归后序遍历二叉树，访问叶子结点
     HTree stack[CHNUM];
     int sign[CHNUM]={0};
     HTree p=T;
     int top=0;

     while( p||top )
     {
         if(p)
         {
             stack[top]=p;
             sign[top]=1;
             top++;
             p=p->lchild ;
         }
         else // p为空指针，循环出栈
             while( top!=0 )   //后序遍历中，当访问完一个结点时，则以该结点为根的树都访问完，所以下一步应该继续出栈，
             {
                 top--;
                 p = stack[top];

                 if( sign[top] == 2 ) //表示p的左右子树都已走过 
                 {
                     if( p->lchild ==0 && p->rchild ==0 )
                         for(int i=1;i<=top;i++)
                             huffCode[p->w.c+PLUS]+=stack[i]->code;
                 }
                 else //表示仅走过T的左子树 ，右子树必定是第一次遇到，
                 {
                     stack[top]=p;
                     sign[top]=2;
                     top++;
                     p=p->rchild;
                     break;
                 }//else if
             } //while ( !IsEmpty )  

             if(top==0)
                 break;
     }//while
     return 0;
 }

 int HuffmanGKM::CompressFile()
 {
     ifstream read;
     read.open (original_file);
     if(read.fail ())
     {
         cout<<"The original file open failed when compress！！！";
         return 1;
     }
     ofstream write;
     write.open(compress_file,ios::binary );
     if(write.fail ())
     {
         cout<<"The compress files open failed when compress！！！" ;
         return 1;
     }
     char next;
     unsigned char buff=0;
     int count=0;

     read.get(next);
     while(!read.eof())
     {
         for(string::size_type i=0;i<huffCode[next+PLUS].size();i++)
         {
             if( huffCode[next+PLUS][i]=='0')
                 buff=(buff<<1);
             else
                 if(huffCode[next+PLUS][i]=='1')
                     buff=(buff<<1)|1;
             count++;
             if(count==8)
             {
                 write<<buff;
                 count=0;
             }
         }
         read.get(next);
     }
     if(count!=0)
         for(;count!=8;count++)
             buff=(buff<<1);
     write<<buff;
     read.close();
     write.close();

     return 0;
 }

 int HuffmanGKM::DecompressFile ()
 {
     ifstream read;
     read.open (compress_file,ios::binary );
     if(read.fail())
     {
         cout<<"The compress file pen failed when decompress!!"<<endl;
         return 0;
     }
     ofstream write;
     write.open (decompress_file);
     if(write.fail())
     {
         cout<<"The decompress file open failed when decompress!!"<<endl;
         return 0;
     }
     HTree p=T;

     char next;
     read.get(next);
     unsigned long long countSize=0;
     while(1)
     {
         bitset<8>b(next);
         read.get(next);
         for(int i=b.size()-1;i>=0;i--)
         {
             if(b.test(i))
                 p=p->lchild ;
             else
                 p=p->rchild ;

             if(p->lchild ==0 && p->rchild ==0)
             {
                 write<<p->w.c;
                 p=T;
                 countSize++;
             }
             if(countSize>=file_size)
                 break;
         }
         if(countSize>=file_size)
                 break;
     }

     read.close ();
     write.close();
     return 0;
 }

 HuffmanGKM::~HuffmanGKM()
 {

     HTree stack[CHNUM];
     int sign[CHNUM]={0};

     HTree p=T;
     int top=0;
     while( p||top )
     {
         if(p)
         {
             stack[top]=p;
             sign[top]=1;
             top++;
             p=p->lchild ;
         }
         else // p为空指针，循环出栈
             while( top!=0 )   //后序遍历中，当访问完一个结点时，则以该结点为根的树都访问完，所以下一步应该继续出栈，
             {
                 top--;
                 p = stack[top];

                 if( sign[top] == 2 ) //表示p的左右子树都已走过 ,后序遍历，释放所有结点
                     delete(p);

                 else //表示仅走过T的左子树 ，右子树必定是第一次遇到，
                 {
                     stack[top]=p;
                     sign[top]=2;
                     top++;
                     p=p->rchild;
                     break;
                 }//else if
             } //while ( !IsEmpty )  

             if(top==0)
                 break;
     }//while
 } 

 //Huffman.cpp : main函数文件。
 #include "stdafx.h"
 #include "HuffmanGKM.h"
 #include <iostream>
 #include <string>

 using std::string;
 using std::cout;
 using std::endl;
 int _tmain(int argc, _TCHAR* argv[])
 {

     string originalFile="../TestGkm/奥巴马.txt";
     string compressFile="../TestGkm/奥巴马compress.txt";
     string decompressFile="../TestGkm/奥巴马decompress.txt";

     HuffmanGKM huff( originalFile, compressFile,decompressFile);

     huff.ReadFile ();
     huff.BuildHuffTree ();
     huff.CreateHuffCode ();
     huff.CompressFile();
     huff.DecompressFile ();

     cout<<"COMPLETE!"<<endl;

     getchar();

     return 0;
 }