文件压缩

文件压缩原理：
1. 建立最小堆
2. 利用最小堆的数据特性建立huffman树结构
3. 统计要压缩的文件中字符出现次数
4. 以字符出现次数为树的权重建立哈夫曼树
5. 遍历huffman树获取字符编码和行数（真正要存储的数据）
6. 创建一个文件（test.compress）存储压缩数据（行数、配置信息）
7. 将字符编码（用字符在huffman树从根节点到叶子结点的路径编码）以位图方式存储在test.compress文件中
文件解压原理：
1. 根据压缩文件test.compress内的配置信息重建huffman树
2. 根据行数跳过配置信息，读取压缩后的数据本体
3. 根据压缩位图中的二进制信息遍历重建的huffman树
4. 建立解压后的文件test.uncompress文件存储遍历得到的字符

源码：
heap.h

#pragma once
#include <iostream>
using namespace std;
#include <vector>
#include <assert.h>

template<class T>
struct Less
{
    bool operator()(const T& left,const T& right)
    {
        return left<right;
    }
};
template<class T>
struct Great
{
    bool operator()(const T& left,const T& right)
    {
        return left>right;
    }
};
template<class T,class Compare=Less>
class Heap
{
public:
    Heap()
        :_heap(NULL)
    {}
    Heap(const T* array,size_t size)
        :_heap(NULL)
    {
        _heap.resize(size);
        for(size_t i=0; i<size; i++)
        {
            _heap[i]=array[i];
        }
        for (int root=(size-2)/2; root>0; root--)
        {
            BuildDown(root);
        }
    }

    void Push(const T& data)
    {
        _heap.push_back(data);
        for (int root=(_heap.size()-1)/2; root>=0; root--)
        {
            BuildDown(root);
        }
    }

    void Pop()
    {
        assert(!_heap.empty());
        size_t size=_heap.size()-1;
        swap(_heap[size],_heap[0]);
        _heap.pop_back();
        for (int root=_heap.size(); root>=0; root--)
        {
            BuildDown(root);
        }
    }
    bool Empty()
    {
        return _heap.empty();
    }
    size_t Size()
    {
        return _heap.size();
    }
    T Top()
    {
        return _heap[0];
    }
private:
    void BuildDown(size_t root)
    {
        size_t parent=root;//倒数第一个非叶子节点
        size_t size=_heap.size();
        size_t child=root*2+1;
        while (child<size)
        {
            if ((child+1<size)&&Compare()(_heap[child+1],_heap[child]))//右孩子存在情况下于左孩子比较找出最小值
            {
                child=child+1;
            }
            if (Compare()(_heap[child],_heap[parent]))//若小于父母节点则交换
            {
                swap(_heap[child],_heap[parent]);
                parent=child;
                child=parent*2+1;
            }
            else 
                return;
        }
    }
private:
    vector<T> _heap;
};
void test()
{
    int arr[]={12,18,24,3,32,74,5};
    size_t size=sizeof(arr)/sizeof(arr[0]);
    Heap<int,Less<int>> h(arr,sizeof(arr)/sizeof(arr[0]));
    h.Push(1);
    h.Pop();
}

HuffmanTree.hpp

#include "heap.hpp"
template<class T>
struct HuffmanNode
{
    HuffmanNode(const T& weight)
        :_Lchild(NULL)
        ,_Rchild(NULL)
        ,_weight(weight)
    {}
    //HuffmanNode* _Parent;
    HuffmanNode* _Lchild;
    HuffmanNode* _Rchild;
    T _weight;
};
template<class T>
class Tree
{
    typedef HuffmanNode<T> Node;
public:
    Tree()
    {}
    Tree(T* array,size_t size,const T& invalid)
    {
        CreatHuffmanTree(array,size,invalid);
        //invalid防止只有一个节点的情况
    }
    ~Tree()
    {
        Destory(_pRoot);
    }
    Node* Root()
    {
        return _pRoot;
    }
private:
    void CreatHuffmanTree(T* array,size_t size,const T& invalid)
    {
        struct Compare//重载比较器
        {
            bool operator()(const Node* left,const Node* right)
            {
                return left->_weight<right->_weight;        
            }
        };
        Heap<Node*,Compare> h;
        for(size_t i=0; i<size; i++)
        {
                if (array[i] != invalid)
                {
                    Node* pRoot=new Node(array[i]);
                    h.Push(pRoot);
                }
        }
        if (h.Size())
        {
            while (h.Size()>1)
            {
                Node *Left=h.Top();
                h.Pop();
                Node *Right=h.Top();
                h.Pop();
                Node* Parent=new Node(Left->_weight+Right->_weight);
                Parent->_Lchild=Left;

                Parent->_Rchild=Right;
                h.Push(Parent);
            }
            _pRoot=h.Top();
        }
        else
            return ;

        //int tmp=(int)_pRoot->_weight._ch;
        //int tmp1=(int)_pRoot->_Lchild->_weight._ch;
        //int tmp2=(int)_pRoot->_Rchild->_weight._ch;

    }
    void Destory(Node* _pRoot)
    {
        if (_pRoot)
        {
            Destory(_pRoot->_Lchild);
            Destory(_pRoot->_Rchild);
            delete _pRoot;
            _pRoot=NULL;
        }
    }
private:
    Node* _pRoot;
};

file_compress.h

#define  _CRT_SECURE_NO_WARNINGS
#include "HuffmanTree.hpp"
#include <string>
#include <windows.h>
#include <cstdlib>
struct File_Info
{
    unsigned char _ch;//字符
    long long _count;//出现次数
    string _code;//字符编码

    File_Info(const long long& count=0)
        :_count(count)
    {}

    File_Info(const char ch)
        :_ch(ch)
    {}

    File_Info operator+(const File_Info& f)const
    {
        return _count+f._count;
    }

    bool operator<(const File_Info& f)const
    {
        return _count<f._count;
    }

    bool operator!=(const File_Info& f)const
    {
        return _count!=f._count;
    }
};

class FileCompress
{
    typedef HuffmanNode<File_Info> Node;
public:

    void Compress(const char* filename)//文件压缩
    {
        FILE* pfr=fopen(filename,"r");
        if (pfr==NULL)
        {
            perror("fail to open the file");
        }
        //统计文件中字符出现次数
        for (int i=0; i<256; i++)
        {
            _Info[i]._ch = i;//所有字符种类
        }

        int ch = fgetc(pfr);
        while (ch!=EOF)
        {
            _Info[ch]._count++;
            ch=fgetc(pfr);
        }
        fclose(pfr);//重置文件指针
        FILE* fpr=fopen(filename,"r");
        Tree<File_Info> tree(_Info, 256, File_Info());//以File_Info结构体为树的权重建立哈夫曼树
        Node* root=tree.Root();

        string code;
        int line=0;
        _GetTreeNode(root,code,line);//获取字符编码和行号

        //添加文件后缀,并重置文件指针
        fseek(pfr,0,SEEK_SET);
        string write(filename);
        write=write+".compress";//存放压缩后数据

        FILE* pfw=fopen(write.c_str(),"w");

        fputs(write.c_str(),pfw);//写入文件名
        fputc('\n',pfw);
        char Line[4];//存储行数
        _itoa(line,Line,10);//转化行数为十进制字符放入文件
        fputs(Line,pfw);
        fputc('\n',pfw);
        for(int i=0; i<256; i++)//写入文件配置信息
        {
            if(_Info[i]._count)//排除没有出现的字符
            {
                fputc(_Info[i]._ch,pfw);
                char arr[126];
                _itoa(_Info[i]._count,arr,10);//转化_count为十进制字符放入文件
                fputc(' ',pfw);
                fputs(arr,pfw);
//              fputc(':',pfw);
//              fputs(_Info[i]._code.c_str(),pfw);
                fputc('\n',pfw);
            }
        }

        unsigned char data = 0;
        int pos=7;
        ch=fgetc(pfr);

        while (ch!=EOF)//写入编码信息
        {
            const char*ptr=_Info[ch]._code.c_str();
            while (*ptr)
            {
                if (pos>=0)
                {
                    data=data | ((*ptr-'0')<<pos);
                    pos--;
                    ptr++;
                }
                else if(pos<0)
                {
                    fputc(data,pfw);//读满8位写入
                    pos=7;
                    data=0;
                }
            }
            ch=fgetc(pfr);//读取下一个字符
        }
        //最后一个字符不管有没有写满都要放进去
        fputc(data,pfw);
        //fputc(EOF,pfw);//写入文件结束符
        fputs("\r\n",pfw);

        fclose(pfr);
        fclose(pfw);
        cout<<"压缩完成"<<endl;
    }

    //文件解压
    void Extract(const char* filename)
    {
        assert(filename);
        FILE* pfr=fopen(filename,"rb");
        File_Info _Info[256];

        string code;
        string write(filename);
        _GetLine(write.c_str(),_Info,code);//重写树节点

        int index=write.rfind(".",write.size());
        if (write.substr(index+1,write.size())!="Compress")//检查文件后缀是否正确
        {
            return ;
        }
        write=write.substr(0, index);//除去文件后缀

        write=write+".UnCompress";
        FILE* pfw=fopen(write.c_str(),"wb");//添加新的后缀并打开解压文件

        Tree<File_Info> newtree(_Info,256,File_Info());
        HuffmanNode<File_Info> *root=newtree.Root();
        HuffmanNode<File_Info> *cur=root;
        if (root==NULL)
        {
            return ;
        }

        long long charcount=root->_weight._count;//字符总数，控制循环条件
        int pos=8;
        const char* ch=code.c_str();//压缩后的数据

        while (charcount)//解压
        {
            --pos;
            unsigned char v=1;
            int tmp=((*ch)&(v<<pos));
            if (tmp)
            {
                cur=cur->_Rchild;
            }
            else if (tmp==0)
            {
                cur=cur->_Lchild;
            }
            if (cur->_Lchild==NULL && cur->_Rchild==NULL)
            {
                fputc(cur->_weight._ch,pfw);//找到编码对应叶节点的字符信息_ch
                cur=root;
                if (--charcount==0)//总字符数
                {
                    break;
                }               
            }
            if (pos==0)
            {
                pos=8;
                ch++;
            }
        }
        fclose(pfr);
        fclose(pfw);
        cout<<"解压结束"<<endl;
    }
protected:
    void _GetTreeNode(Node* root, string code,int& line)//获取字符编码和行数
    {
        if (root==NULL)
            return;
        _GetTreeNode(root->_Lchild, code+'0',line);
        _GetTreeNode(root->_Rchild, code+'1',line);

        if (root->_Lchild==NULL && root->_Rchild==NULL)
        {
            _Info[root->_weight._ch]._code=code.c_str();
            if (root->_weight._count!=0)
            {
                line++;//行数为叶节点个数
            }
        }
    }
    void _GetLine(string filename,File_Info* _Info,string& code)
    {
        FILE* pfr=fopen(filename.c_str(),"r");
        unsigned char ch=fgetc(pfr);
        while(ch!='\n')//最后一位'\n'已被读取
        {
            ch=fgetc(pfr);
        }
        string Line;//存储行数

        for (int i=0; i<4;i++)//行数最位4多
        {
            ch=fgetc(pfr);//读行数
            if (ch=='\n')
                break;
            Line.push_back(ch);
        }

        int line=atoi(Line.c_str());        //将行数转化为整型
        while (line--)
        {
            string buf;     //读取每一行信息
            char ch=fgetc(pfr);
            while (ch!='\n')
            {
                buf.push_back(ch);
                ch=fgetc(pfr);
            }
            //建立叶节点信息
            int index=buf.rfind(" ",buf.size());    //找到space对应下标
            unsigned char c=buf[0];                 //第一个字符为_ch
            _Info[c]._ch=c;
            string str=buf.substr(index,buf.size());//space之后为出现次数_count
            int count=atoi(str.c_str());
            _Info[c]._count=count;
        }

        unsigned char h=fgetc(pfr);//读取压缩后的数据本体

        while (h!=EOF)
        {
            code.push_back(h);
            h=fgetc(pfr);
        }

        //char *rdbuf=new char[1024];
        //int rdsize=fread(rdbuf,1,1024,pfr);
        //while (rdsize!=0)
        //{
        //  break;
        //  code+=fread(rdbuf,1,1024,pfr);
        //}

        //const unsigned char *cur=(const unsigned char *)code.c_str();
        fclose(pfr);
    }

private:
    File_Info _Info[256];
};