用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(0),ncounts(0),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 = 0;
    ncounts = 0;
    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] = '0';
    if(Root.lNext != NULL)
        ErgodicTree(*Root.lNext, szStr, nDeep + 1);
    szStr[nDeep] = '1';
    if(Root.rNext != NULL)
        ErgodicTree(*Root.rNext, szStr, nDeep + 1);
    szStr[nDeep] = 0;
}

/*
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 <= 0)
        return;
    int nOffSet = 0;
    int nFront, nBack;
    T tmpVal;
    for(int i = nModifiedAddr + 1;i < nLength;++ i)
    {
        if(pHead[nModifiedAddr] > pHead[i])
        {
            nOffSet ++;
        }
        else
            break;
    }
    if(nOffSet != 0)
    {
        tmpVal = pHead[nModifiedAddr];
        nFront = nModifiedAddr;
        nBack = nModifiedAddr + nOffSet;
        while(nFront != nBack)
        {
            pHead[nFront] = pHead[nFront + 1];
            nFront ++;
        }
        pHead[nBack] = tmpVal;
        return;
    }

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

}

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

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

    /*
    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 0;
}