一、預備知識

　　給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。
　　本專案使用的Huffman Tree的K-V裡面存放的是字元以及字元出現的次數，構建成Huffman Tree 大體如下：

　　根據這棵樹，我們可以得到每個字元的編碼，例如a的編碼就是1，d的編碼就是000，c的編碼就是001。那麼問題來了，我們要如何得到這棵數呢？得到的編碼又該如何處理呢？

二、具體思路

1. 使用雜湊表統計字元出現的次數

　　構建Huffman Tree我們採用貪心演算法。首先要生成一張關於字元的K-V模型的雜湊表（採用直接定值法）。

CharInfo _hashInfos[256];
//雜湊表儲存元素的資訊：
struct configInfo{
    char _ch;        //字元
    LongType _count; //字元出現的次數
};

注意：此處雜湊表的範圍是[0, 255]，而字元的範圍是[-127, 128]，所以統計字元個數時要先把字元強轉成無符號型別的，例如：_hashTable[(unsigned char)ch]._count++

2. 生成Huffman Tree

• 把雜湊表中的元素插入到優先順序佇列中，構建小堆。
• 從小堆每次拿兩個元素進行相加，將相加後的結果依舊放回到優先順序佇列中，並保持小堆。

HufmanTree(W* w, size_t n, W& invalid)
{
    // 構建哈弗曼樹
    priority_queue<Node*, vector<Node*>, NodeCompare> minHead;
    size_t i = 0;
    for (i = 0; i < n; ++i){
        if (w[i] != invalid)
            minHead.push(new Node(w[i]));
    }
        while (minHead.size() > 1){
        Node* left = minHead.top();
        minHead.pop();
        Node* right = minHead.top();
        minHead.pop();
        Node* parent = new
 
 Node(left->_w + right->_w);
        parent->_left = left;
        parent->_right = right;
        minHead.push(parent);
    }
    _root = minHead.top();
}

3. 生成Huffman Code

void generateHuffmanCode(Node* root)
{
    if(root == nullptr)
        return;

    if(!root->_left && !root->_right){
        _hashInfos[(unsigned char)root->_w._ch]._code = root->_w._code;
           return;
    }

    // 往左邊走，把左孩子的 code 加上'0'
    if(root->_left){
        root->_left->_w._code = root->_w._code + '0';
        generateHuffmanCode(root->_left);
    }

    // 往右邊走，把右孩子的 code 加上'1'
    if(root->_right){
        root->_right->_w._code = root->_w._code + '1';
        generateHuffmanCode(root->_right);
    }
}

4. 開始壓縮

• 把雜湊表中的內容也寫到到壓縮檔案中，方便解壓時重建二叉樹。
• 把字元及其對應的字元編碼寫到壓縮檔案中，逐位元組寫入。
• 如果寫完最後一個字元且不滿一位元組，往裡面填充0。

5. 解壓縮

• 讀取檔案中的雜湊表，重建Huffman Tree。
• 根據Huffman Tree和Huffman Code還原對應字元，寫到解壓縮檔案中。
• 根據Huffman Tree的根節點，確定解壓縮的字元的個數。
  

三、原始碼

// HuffmanTree.h

#ifndef __HUFFMANTREE_H__
#define __HUFFMANTREE_H__

#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>

// 哈弗曼樹節點內容
template<class W>
class HuffmanTreeNode{
public:
    HuffmanTreeNode<W>* _left;
    HuffmanTreeNode<W>* _right;
    HuffmanTreeNode<W>* _parent;
    W _w;

    HuffmanTreeNode(const W& w)
        :_left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _w(w)
    {}
};

// 哈弗曼樹
template<class W>
class HuffmanTree{
    typedef HuffmanTreeNode<W> Node;
public:
    HuffmanTree()
        :_root(NULL)
    {}

    // 仿函式（根據字元出現的次數進行比較）
    struct NodeCompare{
        bool operator()(const Node* l, const Node* r){
            return l->_w > r->_w;
        }
    };

    HuffmanTree(W* w, size_t n, W& invalid)
    {
        // 構建哈弗曼樹
        priority_queue<Node*, vector<Node*>, NodeCompare> minHead;
        size_t i = 0;
        for (i = 0; i < n; ++i){
            if (w[i] != invalid)
                minHead.push(new Node(w[i]));
        }

        while (minHead.size() > 1){
            Node* left = minHead.top();
            minHead.pop();
            Node* right = minHead.top();
            minHead.pop();
            Node* parent = new Node(left->_w + right->_w);
            parent->_left = left;
            parent->_right = right;
            minHead.push(parent);
        }
        _root = minHead.top();
    }

    ~HuffmanTree()
    {
        Destory(_root);
        _root = NULL;
    }

    void Destory(Node* root)
    {
        if (root == NULL){
            return;
        }
        Destory(root->_left);
        Destory(root->_right);
        delete root;
    }

    Node* GetRoot()
    {
        return _root;
    }
private:
    HuffmanTree(const HuffmanTree<W>& t);
    HuffmanTree& operator=(const HuffmanTree<W>& t);
protected:
    Node* _root;
};

#endif //__HUFFMANTREE_H__

// FileCompress.h

#ifndef __FILECOMPRESS_H__
#define __FILECOMPRESS_H__

#include "HuffmanTree.h"
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <assert.h>
#include <string>
using namespace std;

typedef long long LongType;

struct CharInfo{
    char _ch;        //字元
    string _code;    //編碼
    LongType _count; //出現次數

    // 過載+ 是為了在構建哈夫曼樹時，parent = left+right
    CharInfo operator+(const CharInfo& info)
    {
        CharInfo ret;
        ret._count = _count + info._count;
        return ret;
    }

    bool operator>(const CharInfo& info) const
    {
        return _count > info._count;
    }

    bool operator != (const CharInfo& invalid)
    {
        return _count != invalid._count;
    }
};

class FileCompress{
    typedef HuffmanTreeNode<CharInfo> Node;

public:
    struct configInfo
    {
        char _ch;
        LongType _count;
    };
    FileCompress()
    {
        size_t i = 0;
        for (i = 0; i < 256; ++i){
            _hashInfos[i]._ch = i;
            _hashInfos[i]._count = 0;
        }
    }
    void Compress(const char* file)
    {
        // 1.統計檔案中字元出現的次數
        ifstream ifs(file, ios_base::in | ios_base::binary);
        char ch;
        while (ifs.get(ch)){
            // 因為 char的範圍是-127-128，而使用負數做下標對雜湊表進行訪問會出錯，所以強轉成無符號的
            _hashInfos[(unsigned char)ch]._count++;
        }

        // 2.生成哈弗曼樹
        CharInfo invalid;
        invalid._count = 0;
        HuffmanTree<CharInfo> tree(_hashInfos, 256, invalid);

        // 3.生成 Huffman code
        generateHuffmanCode(tree.GetRoot());

        // 4.壓縮
        string compressFile = file;
        // 給壓縮檔案新增字尾
        compressFile += ".huffman";
        ofstream ofs(compressFile.c_str(), ios_base::out | ios_base::binary);

        // 把字元和次數也寫到壓縮檔案中，方便解壓時生成 _hashInfos
        for (size_t i = 0; i < 256; ++i){
            if (_hashInfos[i]._count > 0){
                configInfo info;
                info._ch = _hashInfos[i]._ch;
                info._count = _hashInfos[i]._count;
                ofs.write((char*)&info, sizeof(configInfo));
            }
        }
        configInfo end;
        end._count = 0;
        ofs.write((char*)&end, sizeof(configInfo));

        ifs.clear();  //清理一下，下面seekg才起作用
        ifs.seekg(0);
        char value = 0;
        int pos = 0;

        //把編碼寫入到壓縮檔案中
        while (ifs.get(ch)){
            string& code = _hashInfos[(unsigned char)ch]._code;
            for (size_t i = 0; i < code.size(); ++i){
                if (code[i] == '0') value &= (~(1 << pos));
                else if (code[i] == '1') value |= (1 << pos);
                else assert(false);

                ++pos;
                if (pos == 8){
                    ofs.put(value);
                    pos = 0;
                    value = 0;
                }
            }
        }
        // 如果最後一個位元組沒填滿，直接放進去
        if (pos > 0) ofs.put(value);
    }


    void generateHuffmanCode(Node* root)
    {
        if(root == nullptr)
            return;

        if(!root->_left && !root->_right){
            _hashInfos[(unsigned char)root->_w._ch]._code = root->_w._code;
            return;
        }

        // 往左邊走，把左孩子的 code 加上'0'
        if(root->_left){
            root->_left->_w._code = root->_w._code + '0';
            generateHuffmanCode(root->_left);
        }

        // 往右邊走，把右孩子的 code 加上'1'
        if(root->_right){
            root->_right->_w._code = root->_w._code + '1';
            generateHuffmanCode(root->_right);
        }
    }

    void Uncompress(const char* file)
    {
        // 1. 開啟壓縮檔案，進行解壓
        ifstream ifs(file, ios_base::in | ios_base::binary);
        string uncompressfile = file;
        size_t pos = uncompressfile.rfind('.');
        assert(pos != string::npos);
        uncompressfile.erase(pos);

        uncompressfile += ".unhuffman";
        ofstream ofs(uncompressfile.c_str(), ios_base::out | ios_base::binary);

        // 重構 _hashInfos
        while (1){
            configInfo info;
            ifs.read((char*)&info, sizeof(configInfo));
            if (info._count > 0)
            {
                _hashInfos[(unsigned char)info._ch]._count = info._count;
            }
            else
            {
                break;
            }
        }

        // 2. 重建Huffman Tree
        CharInfo invalid;
        invalid._count = 0;
        HuffmanTree<CharInfo> tree(_hashInfos, 256, invalid);

        // 3. 根據 Huffman Code 解壓縮
        char ch;
        Node* root = tree.GetRoot();
        LongType fileCount = root->_w._count;  //記錄了檔案總字元的個數，為解壓做準備

        Node* cur = root;
        while (ifs.get(ch)){
            for (size_t pos = 0; pos < 8; ++pos){

                if (ch & (1 << pos)) cur = cur->_right;  // 1
                else cur = cur->_left;                   // 0

                if (!cur->_left && !cur->_right) {       //
                    ofs.put(cur->_w._ch);
                    cur = root;

                    if (--fileCount == 0) break; // 解壓完成
                }
            }
        }
    }
private:
    CharInfo _hashInfos[256];
};

void TestFileCompress()
{
    FileCompress fc;
    fc.Compress("Input.txt");
}

void TestFileUncompress()
{
    FileCompress fc;
    fc.Uncompress("Input.txt.huffman");
}

#endif //__FILECOMPRESS_H__

四、壓縮率