用C++实现文件压缩（1 哈弗曼编码）

今天下午想把文件压缩写一下，因为我觉得这个还是比较锻炼技术的，对数据结构的要求应该比较高，权当练习了吧。

我采用的压缩方式是Huffman编码，不过比较囧的是，我拼写拼错了，我拼的是haffman，在后面的代码也是出尽洋相。

huffman是非常经典的一种编码形式，不过现在好像用的不多了，但是这种压缩编码的好处在于数据是无损压缩的，而且非常经典。

在构造huffman树，要做的步骤如下：

1 对文件的元素进行统计，其实就是个计数，我这里的元素是以字节为单位的，毕竟任何文件都可以转化为字节流的形式，处理起来方便的很。

2 然后对统计结果进行一次由小到大的排序，排序的key值就是元素出现的次数。

3 接着取出来排好序的数组的前两个元素，求和，并且再其左右子树上创建这两个元素的副本，然后再扔回首部，此时扔回数组中的，就是包含子树的节点了。在这里有个代码优化的小技巧，能在一定程度上提高效率，减少不必要的操作。

4 此时原来已经排好序的数组可能会遭到破坏，必须重新进行排序，因为数组大体是有序的，所以使用此时效率最高的一步插入排序，时间复杂度仅为O(n)，我专门写了个函数来实现这个功能，并且进行了简单的测试。

5 然后再取出首部的前两个元素，重复上面步骤3，直到数组中的元素个数为1.

最终数组中仅存的元素，就是一棵二叉树的Root。

这样huffman树的构造就完成了。

在huffman树构造完成后，接着要做的就是根据huffman树获取其huffman编码，这个还是很简单的，就是使用递归，左树传入0，右树传入1，依次递归下去，遇到叶子节点就直接输出，当然了，如果需要添加到某个数据结构中，只要在递归函数中给个参数接口，或者设置一个全局的容器，都能解决，换言之，类似于输出重定向。

这样上面的步骤完成后，就能很好的获取到huffman编码了。不过根据huffman编码结果将字符型的0,1写入到二进制中的0，1还有一些比较关键的函数需要处理，还没想到比较好的点子，不过最基础的蛮力方法肯定是能写的，但是，效率就不好说了。

另外获取huffman编码中，用于0,1传递的参数肯定是要用一个buffer的，这个buffer我用的是char字符串，现在有个问题就是，这个字符串的长度只要大于多少就能满足任何2GB以下文件的huffman编码呢？

我觉得这个题可以用来出一道笔试面试题，好好想一想就能想明白的。我的结果是 254，你觉得呢？

最近笔试面试写了不少题，都是被人考，现在我来考考别人~

另外huffman的解码我也基本想到思路了，明天有时间的话就试着明天实现。

程序运行结果：

第一列是字符的数值，第二列是出现的次数，第三列是其huffman编码。

我这代码放眼望去，尽是被拼成了haffman的错误拼写……

程序代码：

 #include <iostream>
 #include <windows.h>
 #include <vector>
 #include <algorithm>
 using namespace std;

 struct HaffmanStruct
 {
     //a small structure
     HaffmanStruct():val(),ncounts(),lNext(NULL),rNext(NULL){}
     bool operator < (HaffmanStruct &);
     bool operator > (HaffmanStruct &);
     void Reset();
     unsigned char val;
     unsigned int ncounts;
     //used for tree
     HaffmanStruct * lNext;
     HaffmanStruct * rNext;
 };

 bool HaffmanStruct::operator > (HaffmanStruct & hs)
 {
     return ncounts > hs.ncounts;
 }

 bool HaffmanStruct::operator < (HaffmanStruct & hs)
 {
     return hs.ncounts > ncounts;
 }

 void HaffmanStruct::Reset()
 {
     val = ;
     ncounts = ;
     lNext = NULL;
     rNext = NULL;
 }

 /*
 Created in 2013 10 03
 ergodic the Haffman tree
 */
 template <class T>
 void ErgodicTree(T & Root, char * szStr, int nDeep)
 {
     if(Root.lNext == NULL && Root.rNext == NULL)
         cout << (int)Root.val << ends << Root.ncounts \
         << ends <<szStr << endl;
     szStr[nDeep] = '';
     if(Root.lNext != NULL)
         ErgodicTree(*Root.lNext, szStr, nDeep + );
     szStr[nDeep] = '';
     if(Root.rNext != NULL)
         ErgodicTree(*Root.rNext, szStr, nDeep + );
     szStr[nDeep] = ;
 }

 /*
 Created in 2013 10 03
 Used in a Array when only one of its member is not sorted
 for ascend sequece
 */
 template <class T>
 void SingleSort(T * pHead, int nLength, const int nModifiedAddr)
 {
     if(pHead == NULL || nLength <= )
         return;
     int nOffSet = ;
     int nFront, nBack;
     T tmpVal;
     for(int i = nModifiedAddr + ;i < nLength;++ i)
     {
         if(pHead[nModifiedAddr] > pHead[i])
         {
             nOffSet ++;
         }
         else
             break;
     }
     if(nOffSet != )
     {
         tmpVal = pHead[nModifiedAddr];
         nFront = nModifiedAddr;
         nBack = nModifiedAddr + nOffSet;
         while(nFront != nBack)
         {
             pHead[nFront] = pHead[nFront + ];
             nFront ++;
         }
         pHead[nBack] = tmpVal;
         return;
     }

     for(int i = nModifiedAddr - ;i >= ;-- i)
     {
         if(pHead[nModifiedAddr] < pHead[i])
         {
             nOffSet --;
         }
         else
             break;
     }
     if(nOffSet != )
     {
         tmpVal = pHead[nModifiedAddr];
         nFront = nModifiedAddr + nOffSet;
         nBack = nModifiedAddr;
         while(nFront != nBack)
         {
             pHead[nBack] = pHead[nBack - ];
             nBack --;
         }
         pHead[nFront] = tmpVal;
         return;
     }

 }

 int _tmain(int argc, _TCHAR* argv[])
 {
     unsigned int aCharCountArray[] = {};
     unsigned char szBuf[];
     DWORD dwReadNum;
     vector<HaffmanStruct> vecValidNumberArray;
     HANDLE hFile = CreateFile(
         _T("C:\\record.txt"),
         GENERIC_READ,
         FILE_SHARE_READ,
         ,
         OPEN_EXISTING,
         FILE_ATTRIBUTE_READONLY,
         NULL);
     if(hFile == INVALID_HANDLE_VALUE)
         return ;
     while(ReadFile(hFile, szBuf, , &dwReadNum, NULL))
     {
         if(dwReadNum == )
             break;
         for(unsigned int i = ;i < dwReadNum;++ i)
         {
             //words count
             aCharCountArray[szBuf[i]] ++;
         }
     }
     //used in the follow two part's code,temp value
     HaffmanStruct ValidStruct;
     for(int i = ;i < ;++ i)
     {
         if(aCharCountArray[i] != )
         {
             ValidStruct.val = i;
             ValidStruct.ncounts = aCharCountArray[i];
             vecValidNumberArray.push_back(ValidStruct);
         }
     }
     sort(vecValidNumberArray.begin(), vecValidNumberArray.end());
     while(vecValidNumberArray.size() != )
     {
         ValidStruct.Reset();
         ValidStruct.ncounts = vecValidNumberArray[].ncounts + vecValidNumberArray[].ncounts;
         ValidStruct.lNext = new HaffmanStruct;
         *ValidStruct.lNext = vecValidNumberArray[];
         ValidStruct.rNext = new HaffmanStruct;
         *ValidStruct.rNext = vecValidNumberArray[];
         vecValidNumberArray.erase(vecValidNumberArray.begin());
         vecValidNumberArray[] = ValidStruct;
         SingleSort(&vecValidNumberArray[], vecValidNumberArray.size(), );
     }

     char Buf[] = {};
     ErgodicTree(vecValidNumberArray[], Buf, );

     /*
     int vecSize = vecValidNumberArray.size();
     for(int i = 0;i < vecSize;++ i)
     {
         cout << (int)vecValidNumberArray[i].val << ends << \
         vecValidNumberArray[i].ncounts << endl;
     }*/
     CloseHandle(hFile);
     system("pause");
     return ;
 }