文件压缩总结-哈夫曼树

详细源代码请移步下载：https://github.com/HsTime/file-campress

项目：文件压缩流程图

建立小堆代码：

#pragma once

#include<iostream>
using namespace std;
#include<vector>
#include"huffman.h"

template<class T>
struct Less
{
    bool operator()(const T & l, const T& n)
    {
        return l < n;
    }
};
template<class T>
struct Greater
{
    bool operator()(const T& l, const T& n)
    {
        return l > n;
    }
};
template<class T, class Comper>
class Heap
{
public:
    Heap()
        :heap(NULL)
    {}
    Heap(T* arr, size_t n)
    {
        heap.reserve(n);
        for (size_t i = 0; i < n; i++)
        {
            heap.push_back(arr[i]);
        }
        int parent = (heap.size() - 2) / 2;
        while (parent >= 0)
        {
            _AdjustDown(parent, heap.size() - 1);
            parent--;
        }
    }
    T Top()
    {
        return heap[0];
    }
    Heap(const vector<T>& x)
    {
        heap.clear();
        heap.resize(x.size(), 0);
        for (size_t i = 0; i < x.size(); i++)
        {
            heap[i] = x[i];
        }
        int parent = (heap.size() - 2) / 2;
        while (parent >= 0)
        {
            _AdjustDown(parent, heap.size() - 1);
            parent--;
        }
    }

    void push(const T& x)
    {
        heap.push_back(x);
        _AdjistUp(heap.size() - 1);
    }

    void Pop()
    {
        swap(heap[0], heap[heap.size() - 1]);
        heap.pop_back();
        _AdjustDown(0, heap.size() - 1);
    }
    bool Empty()
    {
        return heap.empty();
    }
    size_t Size()
    {
        return heap.size();
    }
    void Print()
    {
        vector<int>::iterator it = heap.begin();
        while (it != heap.end())
        {
            cout << *it << " ";
            it++;
        }
        cout << endl;
    }

protected:
    void _AdjustDown(int root, int size)//Ïòϵ÷Õû
    {
        Comper comper;
        int parent = root;
        int child = root * 2 + 1;
        while (child <= size)
        {
            if (child < size && comper(heap[child + 1], heap[child]))
            {
                child++;
            }
            if (comper(heap[child], heap[parent]))
            {
                swap(heap[parent], heap[child]);
                parent = child;
                child = child * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }

    void _AdjistUp(int pos)
    {
        Comper comper;
        int child = pos;
        int parent = (child - 1) / 2;

        while (child > 0)
        {
            if (comper(heap[child], heap[parent]))
            {
                swap(heap[child], heap[parent]);
                child = parent;
                parent = (parent - 1) / 2;
            }
            else
                break;
        }
    }
private:
    vector<T> heap;
};

压缩与解压缩：

#pragma once
#include"huffman.h"
#include<string>
#include<assert.h>

typedef unsigned long long TypeLong;

struct CharInfo
{
    unsigned char _ch; //字符
    TypeLong _count;//出现次数
    string _code;//Huffman编码

    CharInfo(TypeLong count = 0) 
        :_ch(0)
        , _count(count)
        , _code("")
    {}
    bool operator!=(const CharInfo& info)const
    {
        return this->_count != info._count;
    }
    bool operator<(const CharInfo& info)const
    {
        return this->_count < info._count;
    }
    CharInfo operator+(const CharInfo& info)const
    {
        return CharInfo(this->_count + info._count);
    }
};

struct CountInfo
{
    unsigned char _ch;        //字符
    TypeLong _count;          //字符出现的次数
};

class FileCompress
{
public:
    FileCompress();
    void CompressHuffCode(const char* filename);
    void UnCompressHuffCode(const char* filename);
    void PrintCode()const;

protected:
    static void GenerateHuffmanCode(HuffmanNode<CharInfo>* root, FileCompress& file, string& code);

protected:
    CharInfo _info[256];

};
FileCompress::FileCompress()
{
    size_t size = sizeof(this->_info) / sizeof(this->_info[0]);
    for (size_t i = 0; i < size; ++i)
    {
        this->_info[i]._ch = i;
        this->_info[i]._count = 0;
    }
}

void FileCompress::CompressHuffCode(const char* filename)
{
    assert(filename);
    FILE* fOut = fopen(filename, "rb");
    assert(fOut);
    //统计字符出现的次数
    char ch = fgetc(fOut);
    while (!feof(fOut))
    {
        ++this->_info[(unsigned char)ch]._count;
        ch = fgetc(fOut);
    }

    //建立哈夫曼树
    CharInfo invalid;
    invalid._count = 0;
    HuffmanTree<CharInfo> huffTree(this->_info, sizeof(this->_info) / sizeof(this->_info[0]), invalid);

    //生成哈夫曼编码
    string code;
    HuffmanNode<CharInfo>* root = huffTree.GethuffmanNode();
    GenerateHuffmanCode(root, *this, code);

    //生成压缩文件名及配置文件名
    string fileInName = (string)filename; //压缩文件名
    string fileConfig = fileInName;//配置文件名
    size_t last_ = fileInName.find_last_of('.');
    if (last_ < fileInName.size())
    {
        fileInName.erase(last_);
        fileConfig.erase(last_);
    }
    fileInName += ".huff";
    fileConfig += ".config";


    string tmp;
    CountInfo info;
    //生成压缩配置文件
    FILE* fConfig = fopen(fileConfig.c_str(), "wb");
    for (size_t i = 0; i < 256; ++i)
    {
        if (_info[i]._count)
        {
            info._ch = _info[i]._ch;
            info._count = _info[i]._count;
            fwrite(&info, sizeof(info), 1, fConfig);
        }
    }
    info._count = -1;
    fwrite(&info, sizeof(info), 1, fConfig);

    //对文件进行压缩
    FILE* fIn = fopen(fileInName.c_str(), "wb");
    assert(fIn);
    fseek(fOut, 0, SEEK_SET);
    int pos = 0;
    unsigned char putch = 0;
    ch = fgetc(fOut);
    while (!feof(fOut))
    {
        tmp = this->_info[(unsigned char)ch]._code;
        for (size_t i = 0; i < tmp.size(); ++i)
        {
            putch <<= 1;
            putch |= (tmp[i] - '0');
            if (++pos == 8)
            {
                fputc(putch, fIn);
                pos = 0;
                putch = 0;
            }
        }
        ch = fgetc(fOut);
    }
    if (pos > 0)
    {
        putch <<= (8 - pos);
        fputc(putch, fIn);
    }

    fclose(fOut);
    fclose(fIn);
    fclose(fConfig);
}

void FileCompress::GenerateHuffmanCode(HuffmanNode<CharInfo>* root, FileCompress& file, string& code)
{
    if (root == NULL)
    {
        return;
    }
    if (root->_left == NULL && root->_right == NULL)
    {
        file._info[root->_weight._ch]._code = code;
        return;
    }
    code.push_back('0');
    GenerateHuffmanCode(root->_left, file, code);
    code.pop_back();
    code.push_back('1');
    GenerateHuffmanCode(root->_right, file, code);
    code.pop_back();
}

void FileCompress::UnCompressHuffCode(const char* filename)
{
    assert(filename);
    FILE* fOut = fopen(filename, "rb");
    assert(fOut);
    //读取文件，
    string fileConfig = (string)filename;
    string fileInName = fileConfig;
    size_t last_ = fileInName.find_last_of('.');
    if (last_ < fileInName.size())
    {
        fileConfig.erase(last_);
        fileInName.erase(last_);
    }
    fileConfig += ".config";
    /*fileInName += "_Com.JPG";*/
    fileInName += "_Com.mp3";
    /*fileInName += "_Com.txt";*/
    /*fileInName += "_Com.doc";*/

    FILE* fIn = fopen(fileInName.c_str(), "wb");
    assert(fIn);
    FILE* fConfig = fopen(fileConfig.c_str(), "rb");
    assert(fConfig);

    CountInfo info;
    //读配置信息
    while (1)
    {
        fread(&info, sizeof(CountInfo), 1, fConfig);
        if (info._count == -1)
        {
            break;
        }
        _info[(unsigned char)info._ch]._ch = info._ch;
        _info[(unsigned char)info._ch]._count = info._count;
    }

    //重建哈夫曼树
    HuffmanTree<CharInfo> tree(this->_info, sizeof(this->_info) / sizeof(this->_info[0]), 0);
    HuffmanNode<CharInfo>* root = tree.GethuffmanNode();
    HuffmanNode<CharInfo>* cur = root;
    unsigned char ch = fgetc(fOut);
    int pos = 7;
    if (ch  == 255)
    {
        if (info._ch != 0)
        while (_info[(unsigned char)info._ch]._count--)
        {
            {
                fputc(info._ch, fIn);
            }
        }
    }
    else
    {
        TypeLong countSum = root->_weight._count;
        while (countSum > 0)
        {
            while (pos >= 0)
            {
                if ((ch & (1 << pos)) == 0) //向左走
                {
                    cur = cur->_left;
                }
                else
                {
                    cur = cur->_right;
                }
                if (cur->_left == NULL && cur->_right == NULL)
                {
                    fputc(cur->_weight._ch, fIn);
                    //cout << cur->_weight._ch;

                    if (--countSum == 0)//将没有写的字符的次数减1
                        break;
                    cur = root;
                }
                --pos;
            }
            pos = 7;
            ch = fgetc(fOut);
        }
    }
    fclose(fIn);
    fclose(fOut);
    fclose(fConfig);
}

void FileCompress::PrintCode()const
{
    for (int i = 0; i < 256; ++i)
    {
        if (this->_info[i]._count != 0)
        {
            cout << this->_info[i]._ch << ":>" << this->_info[i]._code << endl;
        }
    }
}

（2）为什么要使用配置文件？
在项目中，将字符对应的编码转化为位，在unsigned char中填充位，填满后就写入到压缩文件中。
问题1：最后一个字节是不是很有可能没有填满，该如何判断他是否填满以及填了几个字符的编码？
问题2：若依次压缩一些文件，压缩完后再去解压，那么编码此时已经没有了，该如何解压？
上面的两个问题可通过配置文件解决，假如要压缩的文件叫xxx，那么可生成一个xxx.config的配置文件，在该配置文件中写入<文件的总长度>(恢复时知道应该应该恢复多少个字符)，（字符以及其出现的次数，用于解压时重建哈夫曼树），利用该配置文件即可解决这两个问题。