Huffman编码实现文件的压缩与解压缩。

以前没事的时候写的，c++写的，原理很简单，代码如下：

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <string>
 //#include <bitset>
 #include <fstream>
 #include <ctime>

 const int maxCodeNum = ;

 using namespace std;

 //哈夫曼树的树节点
 struct HaffTreeNode{
     HaffTreeNode * lNode;
     HaffTreeNode * rNode;
     string  haffCode;
     int value;
     int alpha;
     HaffTreeNode()
         :lNode(NULL), rNode(NULL), haffCode(""), value(), alpha(){;}
 };

 //链表节点，用于生成哈夫曼树
 struct ListNode{
     struct HaffTreeNode HaffTreeNode;
     ListNode *nextListNode;
     ListNode()
         :nextListNode(NULL){;}
 };

 //用与保存输入文件统计信息的hash表
 typedef struct HashTable{
     int value;
     int alpha;
     HashTable()
         :value(), alpha(){}
     //比较函数用于排序使用
     inline friend int operator-(const HashTable & a, const HashTable & b){
         return a.value - b.value;
     }
 } HashTable;
 HashTable charHashTable[maxCodeNum];

 //排序使用的比较大小的函数
 int hashComp(const void * a, const void * b)
 {
     return  *((HashTable *)a) - *((HashTable *)b);
 }

 //创建一个哈夫曼树
 HaffTreeNode * createHaffTreeNodeTree(HashTable table[])
 {
     ListNode *root = new ListNode;
     ListNode *next = root;
     for(int i = ; /*i < maxCodeNum - 1*/; ++i){
         if(table[i].value == )//如果对应的码不为0，就为其分配一个树节点
             continue;
         next->HaffTreeNode.alpha = table[i].alpha;
         next->HaffTreeNode.value = table[i].value;
         if(i ==maxCodeNum - )
             break;
         next->nextListNode = new ListNode;
         next = next->nextListNode;
     }

     while(root->nextListNode != NULL){
         ListNode * currNode = new ListNode;
         currNode->HaffTreeNode.value = root->HaffTreeNode.value + root->nextListNode->HaffTreeNode.value;
         currNode->HaffTreeNode.lNode =  &(root->HaffTreeNode);
         currNode->HaffTreeNode.rNode =  &(root->nextListNode->HaffTreeNode);
         root = root->nextListNode->nextListNode;    //概率最小的两个码相加组成一个新的节点

         ListNode * nextNode = root;
         ListNode * prevNode = NULL;
         while(nextNode != NULL && currNode->HaffTreeNode.value > nextNode->HaffTreeNode.value){
             prevNode = nextNode;
             nextNode = nextNode->nextListNode;
         }

         if(prevNode == NULL){//将这个新的节点插入到所有节点之前（currNode目前还是最小的）
             currNode->nextListNode = nextNode;
             root = currNode;
         }else{//插入到节点中间或者节点之后的位置
             prevNode->nextListNode = currNode;
             currNode->nextListNode = nextNode;
         }
     }//在这个list中所有的元素遍历完成之后返回
     return &(root->HaffTreeNode);//返回书的根节点的哈弗满节点，这个节点已经构造成为了一棵树
 }

 string huffmanCodeTable[maxCodeNum];
 string haffCode;

 //给哈夫曼树编码
 void createHaffmanTable(HaffTreeNode * root)
 {
     if(root->lNode == NULL && root->rNode == NULL){
         huffmanCodeTable[root->alpha] = haffCode;
         haffCode.erase(haffCode.length() - );
         return;
     }//给各个节点赋予相应的哈夫曼编码
     haffCode.append("");
     createHaffmanTable(root->lNode);

     haffCode.append("");
     createHaffmanTable(root->rNode);

     if(!haffCode.empty()){
         haffCode.erase(haffCode.length() - );
     }
     return;
 }

 //将生成的二进制长串编码转换成字符用于存储在压缩文件中
 unsigned char StrToBin(string str)
 {
     unsigned int ans =;
     int tmpNum = atoi(str.c_str());
     int multiNum = ;
     while(tmpNum != ){
         ans += tmpNum%*multiNum;
         tmpNum/=;
         multiNum *= ;
     }
     return (unsigned char) ans;
 }

 //用于将压缩文件的字符转换成huffman编码
 string BinToStr(unsigned char c)
 {
     string tmpNumStr;
     while(c != ){
         tmpNumStr.insert(tmpNumStr.begin(), (unsigned char)(c% + ''));
         c /= ;
     }
     if(tmpNumStr.length() < ){
         tmpNumStr.insert(tmpNumStr.begin(),   - tmpNumStr.length(), '');
     }
     return tmpNumStr;
 }

 //下面是将huffman码译成原字符的程序
 char huffDecode(HaffTreeNode * root, string & code)
 {
     unsigned int i;
     for( i = ; i < code.length(); ++i){
         if(root->alpha == )
             root = (code[i] - '')?root->rNode:root->lNode;
         else{
             code.erase(, i);
             return root->alpha;
         }
     }
     if(root->alpha !=){
         code.erase(, i);
         return root->alpha;
     }
     code.clear();
     return '\0';
 }

 int main(int argc, char ** argv)
 {
     if(argc != ){
         printf("Error number of arguments!\n");
     }
     FILE * fin = fopen(argv[], "r");
     int c = ;
     while((c = fgetc(fin)) != EOF && c != '\n'){
         putchar(c);
         putchar('*');
         charHashTable[c].alpha = c;
         charHashTable[c].value++;
     }

     qsort(charHashTable, sizeof(charHashTable)/sizeof(charHashTable[]),
             sizeof(charHashTable[]), hashComp);
     /*建立有关本文件的huffman树*/
     HaffTreeNode * haffTreeRoot = createHaffTreeNodeTree(charHashTable);
     createHaffmanTable(haffTreeRoot);

     cout << "Char\tTimes\tCodes";
     for(int i = ; i < maxCodeNum; ++i){
         if(charHashTable[i].value != ){
             cout << (char)charHashTable[i].alpha << "\t" << charHashTable[i].value
                  << "\t" << huffmanCodeTable[charHashTable[i].alpha] << "\n";
         }
     }

     FILE * fout;
     if((fout = fopen(argv[], "w")) == NULL){
         perror("open output file error!\n");
     }
     rewind(fin);
     string buf; 

     while((c = fgetc(fin)) != EOF){ /*将文件通过huffman码转来进行压缩*/
         //printf("The char is %c  ", c);
         buf += huffmanCodeTable[c];
         cout << buf << endl;
         if(buf.length() > ){   //当转换的字符得到的huffman码达到8的时候转换成一个字符填入目标文件
             fputc(StrToBin(buf.substr(, )), fout);
             buf.erase(, );
         }
     }

     int leftZero = ;   //保存不到8位的余留位的个数
     if(!buf.empty()){
         buf.append((leftZero =  - buf.length()), '');
         fputc(StrToBin(buf), fout);
     }

     if(fclose(fin) == -)
         perror("close file error!\n");
     if(fclose(fout) == -)
         perror("close file error!\n");

     if((fin = fopen(argv[], "rb")) == NULL)//打开压缩文件，开始解码
         perror("Open file error!\n");
     if((fout = fopen("huffmanDecompose.txt", "w")) == NULL)
         perror("Open file error!\n");

     //开始解码
     int bin;
     buf.clear();
     while((bin = fgetc(fin)) != EOF){
         buf.append(BinToStr(bin));
     }

     while(buf.length() - leftZero !=  && !buf.empty()){
         fputc(huffDecode(haffTreeRoot, buf), fout);
     }
     if(fclose(fin) != )
         perror("close file error!\n");
     if(fclose(fout) != )
         perror("close file error!\n");
     return ;
 }

./a.out file1 file2
file1:输入文件
file2:输出文件（压缩后）
要锁完成后会将文压缩文件解压到huffmanDecompose.txt这个文件中