小项目-文件压缩（哈夫曼树）

先回顾一下哈夫曼树
huffman树即最优二叉树，是加权路径长度最短的二叉树。哈夫曼树的树使用贪心算法。

每次选择该集合中权值最小的两个作为叶子结点，父亲节点的权值为叶子节点权值之和。然后又将其父亲重新放进此集合里。重复前面的做法，直到完成哈夫曼树的建立。
每次都要在集合中找出2个权值最小的。这里我们就可以建立一个小堆，每次找出最小的时候只需要向上调整堆就行了。
那么文件哈夫曼树怎么实现文件压缩的呢。
1.统计文件中字符出现的个数
2.每个字符的个数作为权值构建哈夫曼树，这样每个字符对应的权值为叶子结点，然后获取每个叶子节点的哈夫曼编码。
3.进行压缩，哈夫曼编码满8位写进压缩文件。
4.解压缩。

代码实现

//heap.h#define _CRT_SECURE_NO_WARNINGS 1#pragma once#include <iostream>#include<vector>using namespace std;template<class T>struct Less{    bool operator()(const T& l, const T& r)    {        return l < r;    }};template<class T,class Compare=Less<T>>class Heap{public:    Heap()    {}    Heap(T* a, size_t n)    {        _a.reserve(n);        for (size_t i = 0; i < n; i++)        {            _a.push_back(a[i]);        }        for (int i = (_a.size() - 2) / 2; i >= 0; i--)        {            _AdjustDown(i);        }    }    void Push(const T& x)    {        _a.push_back(x);        _AdjustUp(_a.size() - 1);    }    void Pop()    {        swap(_a[0], _a[_a.size() - 1]);        _a.pop_back();        _AdjustDown(0);    }    T& Top()    {        return _a[0];    }    size_t Size()    {        return _a.size();    }protected:    void _AdjustDown(int root)    {        Compare compare;        int parent = root;        int child = parent * 2 + 1;        while (child < (int)_a.size())        {            if (child <(int) _a.size() - 1 && compare(_a[child + 1] ,_a[child]))            {                child++;            }            if (compare(_a[child] ,_a[parent]))            {                swap(_a[parent], _a[child]);                parent = child;                child = parent * 2 + 1;            }            else            {                break;            }        }    }    void _AdjustUp(int root)    {        Compare compare;        int child = root;        int parent = (child - 1) >> 1;        while (child > 0)        {            if (compare(_a[child], _a[parent]))            {                swap(_a[parent], _a[child]);                child = parent;                parent = (child - 1) >> 1;            }            else            {                break;            }        }    }protected:    vector<T> _a;};void TestHeap(){    int a[] = { 1, 3, 9, 3, 54, 87, 21, 15, 8 };    int n = sizeof(a) / sizeof(a[0]);    Heap<int> hp(a, n);    hp.Push(2);}

//huffman.h#define _CRT_SECURE_NO_WARNINGS 1#pragma once#include"heap.h"template<class T>struct HuffmanTreeNode{    T _w;    HuffmanTreeNode<T>* _left;    HuffmanTreeNode<T>* _right;    HuffmanTreeNode<T>* _parent;    HuffmanTreeNode(const T& x)        :_w(x)        , _left(NULL)        , _right(NULL)        , _parent(NULL)    {}};template<class T>class HuffmanTree{    typedef HuffmanTreeNode<T> Node;public:    HuffmanTree()        :_root(NULL)    {}    ~HuffmanTree()    {        _Destory(_root);        _root = NULL;    }    HuffmanTree(T* a, size_t n,const T& invalid)    {        struct Compare        {            bool operator()(Node* l, Node* r)            {                return l->_w < r->_w;            }        };        Heap<Node* ,Compare> minHeap;        for (size_t i = 0; i < n; i++)        {            if (a[i] != invalid )            {                minHeap.Push(new Node(a[i]));            }        }        //贪心算法        while (minHeap.Size()>1)        {            Node* left = minHeap.Top();            minHeap.Pop();            Node* right = minHeap.Top();            minHeap.Pop();            Node* parent = new Node(left->_w + right->_w);            parent->_left = left;            parent->_right = right;            left->_parent = parent;            right->_parent= parent;            minHeap.Push(parent);        }        _root = minHeap.Top();    }    Node*& GetRoot()    {        return _root;    }public:    void _Destory(Node* root)    {        if (root == NULL)        {            return;        }        _Destory(root->_left);        _Destory(root->_right);        delete root;    }protected:    Node* _root;};/*void TestHuffManTree(){    int a[] = { 0, 4, 2, 1, 3, 0};    int n = sizeof(a) / sizeof(a[0]);    HuffmanTree<int> t(a, n, 0);    cout << endl;}*/

//FileCompress.h#define _CRT_SECURE_NO_WARNINGS 1#include"heap.h"#include"HuffManTree.h"#include<string>#include<assert.h>#include<algorithm>typedef long long longtype;struct CharInfo{    longtype _count;//字符出现的次数    string _code;//字符的哈夫曼编码    char _ch;//字符    CharInfo(const longtype x=0)        :_count(x)    {}    bool operator!=(const CharInfo& info)    {        return _count != info._count;    }    CharInfo operator+(const CharInfo& info)    {    return CharInfo(_count + info._count);    }    bool operator <(const CharInfo& info)    {        return _count < info._count;    }};struct CountInfo{    char _ch;    longtype _count;    CountInfo()        :_count(0)    {}};class FileCompess{public:    FileCompess()    {        for (int i = 0; i < 256; i++)        {            _infos[i]._ch = i;            _infos[i]._count = 0;        }    }    void Compess(const char* filename)    {        //统计字符个数        assert(filename);        FILE* fout = fopen(filename, "rb");        assert(fout);        char ch = fgetc(fout);        while (!feof(fout))        {            _infos[(unsigned char)ch]._count++;            ch = fgetc(fout);        }    //构建哈夫曼树        CharInfo invalid;        invalid._count = 0;        HuffmanTree<CharInfo> tree(_infos, 256, invalid);        //获取哈夫曼编码        GetHuffmanCode(tree.GetRoot());        //压缩        string compressfile = filename;        compressfile += ".huffman";        FILE* fin = fopen(compressfile.c_str(), "wb");        assert(fin);        fseek(fout, 0, SEEK_SET);//将指针偏移到文件开始        ch = fgetc(fout);        int pos = 0;        char value = 0;        while (!feof(fout))        {            string& code = _infos[(unsigned char)ch]._code;            for (size_t i = 0; i < code.size(); i++)            {                value <<= 1;                if (code[i] == '1')                {                    value |= 1;                }                else                {                    value |= 0;                }                   pos++;                if (pos == 8)                {                    fputc(value, fin);                    pos = 0;                    value = 0;                }            }            ch = fgetc(fout);        }        if (pos)        {            value <<= (8 - pos);            fputc(value, fin);        }        //写配置文件为解压缩        string configfile = filename;        configfile += ".config";        FILE* fcon = fopen(configfile.c_str(), "wb");        assert(fcon);        CountInfo info;        for (size_t i = 0; i < 256; i++)        {            if (_infos[i]._count)            {                info._ch = _infos[i]._ch;                info._count = _infos[i]._count;                fwrite(&info, sizeof(info), 1, fcon);            }        }        CountInfo info2;        info2._count = -1;        fwrite(&info2, sizeof(info2), 1, fcon);         fclose(fout);        fclose(fin);        fclose(fcon);    }    void UnCompess(const char* filename)    {    //读配置文件        string configfile = filename;        configfile += ".config";        FILE* confile = fopen(configfile.c_str(), "rb");        CountInfo info;        while (1)        {            fread(&info, sizeof(info), 1, confile);            if (info._count == -1)            {                break;            }            _infos[(unsigned char)info._ch]._ch = info._ch;            _infos[(unsigned char)info._ch]._count = info._count;        }        string uncompressfile(filename);        size_t pos = uncompressfile.rfind('.');        assert(pos != string::npos);        uncompressfile = uncompressfile.substr(0,pos);        uncompressfile += ".unhaffman";        //还原的文件        FILE* fin = fopen(uncompressfile.c_str(), "wb");        assert(fin);        //压缩的文件        string file = filename;        file += ".huffman";        FILE* fout = fopen(file.c_str(), "rb");        assert(fout);        //重建哈夫曼树        CharInfo invalid;        invalid._count = 0;        HuffmanTree<CharInfo>tree(_infos, 256, invalid);        HuffmanTreeNode<CharInfo>* root = tree.GetRoot();        HuffmanTreeNode<CharInfo>* cur = root;        longtype count = root->_w._count;        char value = fgetc(fout);         while (!feof(fout))        {            int pos = 7;            char test = 1;            while (pos >= 0)            {                if (value & (test << pos))//找出读出字符的每一位                {                    cur = cur->_right;                }                else                {                    cur = cur->_left;                }                if (cur->_left == NULL&&cur->_right == NULL)                {                    fputc(cur->_w._ch, fin);                    cur = root;                    count--;                }                pos--;            }            if (count == 0)//循环从这退出，当压缩的时候，最后不够8位就会补0，count是字符的个数，当解压缩的count==0时，说明已解压缩完成，就不会把无效的字符解压说出来。            {                break;            }            value = fgetc(fout);                }        fclose(fout);        fclose(fin);    }protected:    //构建哈夫曼编码    void GetHuffmanCode(HuffmanTreeNode<CharInfo>* root)    {        if (root == NULL)        {            return;        }       if (root->_left == NULL&&root->_right == NULL)        {            HuffmanTreeNode<CharInfo>* cur = root;            HuffmanTreeNode<CharInfo>* parent = cur->_parent;            string& code = _infos[(unsigned char)root->_w._ch]._code;            while (parent)            {                if (cur == parent->_left)                {                    code += '0';                }                else                {                    code += '1';                }                cur = parent;                parent = cur->_parent;            }            reverse(code.begin(), code.end());        }       GetHuffmanCode(root->_left);       GetHuffmanCode(root->_right);    }protected:    CharInfo _infos[256];};void test(){    //TestHeap();    //TestHuffManTree();    FileCompess t;    t.Compess("x.jpg");    //cout << "压缩成功" << endl;    //t.Compess("xs.jpg");     //t.UnCompess("xs.jpg");    t.UnCompess("x.jpg");    cout << "解压成功" << endl;}

注：在做的时候哈夫曼树一定先要测试好，要不然就是你调试的一大坑。还右要用到的仿函数都要一一实现。记得一定要强转成unsigned char，否则程序会崩掉。这里我用的的是二进制读写文件，所以用feof来判断文件结束。写配置文件考虑到精度的丢失，用了结构体写进读出。