文件压缩

项目名称《文件压缩》

开发环境：windows，vs2013

所用到的技术：heap，哈夫曼树，哈夫曼编码，c++

文件压缩项目的大致思路：

1.利用小堆进行构建哈夫曼树，然后利用哈夫曼树获得要压缩的每个字符的哈夫曼编码

2.利用哈夫曼编码对源文件进行压缩，就是在压缩文件中按顺序存入各字符对应的哈夫曼编码，并编写配置文件

3.利用配置文件获得各个字符及字符出现的次数，再次用小堆构建哈夫曼树

4.利用哈夫曼树对压缩文件进行解压。

下边是具体实现的代码：

Heap.h --->构建小堆

#pragma once
#include <vector>
#include<assert.h>

// 小堆
template<class T>
struct Less
{
bool operator() (const T& l, const T& r)
{
return l < r;
}
};

template<class T>
struct Greater
{
bool operator() (const T& l, const T& r)
{
return l > r;
}
};

template<class T, class Compare = Less<T>>
class Heap
{
public:
Heap()
{}

Heap(const T* a, size_t size)
{
for (size_t i = 0; i < size; ++i)
{
_arrays.push_back(a[i]);
}

// 建堆
for (int i = (_arrays.size() - 2) / 2; i >= 0; --i)
{
AdjustDown(i);
}
}

void Push(const T& x)
{
_arrays.push_back(x);
AdjustUp(_arrays.size() - 1);
}

void Pop()
{
assert(_arrays.size() > 0);
swap(_arrays[0], _arrays[_arrays.size() - 1]);
_arrays.pop_back();

AdjustDown(0);
}

T& Top()
{
assert(_arrays.size() > 0);
return _arrays[0];
}

bool Empty()
{
return _arrays.empty();
}

int Size()
{
return _arrays.size();
}

void AdjustDown(int root)
{
size_t child = root * 2 + 1;

Compare com;
while (child < _arrays.size())
{
if (child + 1<_arrays.size() &&
com(_arrays[child + 1], _arrays[child]))
{
++child;
}

if (com(_arrays[child], _arrays[root]))
{
swap(_arrays[child], _arrays[root]);
root = child;
child = 2 * root + 1;
}
else
{
break;
}
}
}

void AdjustUp(int child)
{
int parent = (child - 1) / 2;

while (child > 0)
{
if (Compare()(_arrays[child], _arrays[parent]))
{
swap(_arrays[parent], _arrays[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}

void Print()
{
for (size_t i = 0; i < _arrays.size(); ++i)
{
cout << _arrays[i] << " ";
}
cout << endl;
}

public:
/*T* _array;
size_t _size;
size_t _capacity;*/

vector<T> _arrays;
};

哈夫曼树的实现代码 HuffmanTree.h ：

#pragma once
#include "Heap.h"
#include<assert.h>

template<class T>
struct HuffmanTreeNode
{
HuffmanTreeNode<T>* _left;
HuffmanTreeNode<T>* _right;
HuffmanTreeNode<T>* _parent;
T _weight;

HuffmanTreeNode(const T& x)
:_weight(x)
, _left(NULL)
, _right(NULL)
, _parent(NULL)
{}
};

template<class T>
class HuffmanTree
{
typedef HuffmanTreeNode<T> Node;

public:

HuffmanTree()
:_root(NULL)
{}

~HuffmanTree()
{
Destory(_root);
}

template <class T>
struct NodeCompare
{
bool operator()(Node *l, Node *r)
{
return l->_weight < r->_weight;
}
};

public:
void CreatTree(const T* a, size_t size, const T& invalid)
{
assert(a);
Heap<Node*, NodeCompare<T>> minHeap;
for (size_t i = 0; i < size; ++i)
{
if (a[i] != invalid)
{
Node* node = new Node(a[i]);
minHeap.Push(node);
}
}

while (minHeap.Size() > 1)
{
Node* left = minHeap.Top();
minHeap.Pop();
Node* right = minHeap.Top();
minHeap.Pop();

Node* parent = new Node(left->_weight + right->_weight);
parent->_left = left;
parent->_right = right;
left->_parent = parent;
right->_parent = parent;

minHeap.Push(parent);
}

_root = minHeap.Top();
}

Node* GetRootNode()
{
return _root;
}

void Destory(Node* root)
{
if (root)
{
Destory(root->_left);
Destory(root->_right);
delete root;
root = NULL;
}
}
private:
HuffmanTreeNode<T>* _root;
};

文件压缩的实现 ---> FileCompress.h

#pragma once
#include"HuffmanTree.h"
#include<algorithm>
#include<windows.h>
#include<string.h>
using namespace std;

typedef long long Longtype;//为了扩大其范围，int型能处理的范围已经不能满足，所以定义Long Long型予以表示

struct CharInfo
{
unsigned char _ch;//这里必须为unsigned，否则会造成截断，所以从-128~127调至0~255.
Longtype _count;
string _code;

CharInfo(unsigned char ch = 0)
:_ch(ch)
, _count(0)
{}

CharInfo operator+(CharInfo& file)
{
CharInfo tmp;
tmp._count = this->_count + file._count;
return tmp;
}

bool operator < (CharInfo& file)
{
return this->_count < file._count;
}

bool operator != (const CharInfo& file)const
{
return this->_count != file._count;
}
};

template<class T>
class FileCompress
{
public:
FileCompress()
{
for (int i = 0; i < 256; ++i)
{
_arr[i]._ch = i;
}
}

public:

bool Compress(const char* filename)
{
//1.打开文件，统计文件字符出现的次数
long long Charcount = 0;
assert(filename);
FILE* fOut = fopen(filename, "rb");//"rb"为以二进制方式读取文件，这里的b就是binary。"wb"为以二进制方式写入文件
assert(fOut);					//以二进制和文本打开方式区别在于：以文本打开方式会将\r\n
//转换为\n,二进制这不会有这样的转换
char ch = fgetc(fOut);

while (ch != EOF)
{
_arr[(unsigned char)ch]._count++;
ch = fgetc(fOut);
Charcount++;
}

//2.生成对应的huffman编码
GenerateHuffmanCode();

//3.文件压缩
string compressFile = filename;
compressFile += ".compress";
FILE* fwCompress = fopen(compressFile.c_str(), "wb");
assert(fwCompress);

fseek(fOut, 0, SEEK_SET);
ch = fgetc(fOut);
char inch = 0;
int index = 0;
while (!feof(fOut))
{
string& code = _arr[(unsigned char)ch]._code;
for (size_t i = 0; i < code.size(); ++i)
{
inch = inch << 1;
if (code[i] == '1')
{
inch |= 1;
}
if (++index == 8)//对于形成的长串字符编码的切割，每8个bit为一个字节，便于读取
{
fputc(inch, fwCompress);
inch = 0;
index = 0;
}
}
ch = fgetc(fOut);
}

if (index)//考虑到可能会有切割完，剩余的字符码不够填充8个bit位的情况
{
inch = inch << (8 - index);
fputc(inch, fwCompress);
}

//4.配置文件，方便后续的解压缩；
string configFile = filename;
configFile += ".config";
FILE *fconfig = fopen(configFile.c_str(), "wb");
assert(fconfig);

char CountStr[128];
_itoa(Charcount >> 32, CountStr, 10);
fputs(CountStr, fconfig);
fputc('\n', fconfig);
_itoa(Charcount & 0xffffffff, CountStr, 10);
fputs(CountStr, fconfig);
fputc('\n', fconfig);

CharInfo invalid;
for (int i = 0; i < 256; i++)
{
if (_arr[i] != invalid)
{
fputc(_arr[i]._ch, fconfig);
fputc(',', fconfig);
fputc(_arr[i]._count + '0', fconfig);
fputc('\n', fconfig);
}
}

fclose(fOut);
fclose(fwCompress);
fclose(fconfig);

return true;
}
//文件的解压
bool UnCompresss(const char* filename)
{
string configfile = filename;
configfile += ".config";
FILE* outConfig = fopen(configfile.c_str(), "rb");
assert(outConfig);
char ch;
long long Charcount = 0;
string line = ReadLine(outConfig);
Charcount = atoi(line.c_str());
Charcount <<= 32;
line.clear();
line = ReadLine(outConfig);
Charcount += atoi(line.c_str());
line.clear();

while (feof(outConfig))
//feof()遇到文件结束，函数值为非零值，否则为0。当把数据以二进制的形式进行存放时，可能会有-1值的出现，
//所以此时无法利用-1值（EOF）做为eof()函数判断二进制文件结束的标志。
{
line = ReadLine(outConfig);
if (!line.empty())
{
ch = line[0];
_arr[(unsigned char)ch]._count += atoi(line.substr(2).c_str());
line.clear();
}
else
{
line = '\n';
}
}

HuffmanTree<CharInfo> ht;
CharInfo invalid;
ht.CreatTree(_arr, 256, invalid);//重新建树

HuffmanTreeNode<CharInfo>* root = ht.GetRootNode();

string  UnCompressFile = filename;
UnCompressFile += ".uncompress";
FILE* fOut = fopen(UnCompressFile.c_str(), "wb");

string CompressFile = filename;
CompressFile += ".compress";
FILE* fIn = fopen(CompressFile.c_str(), "rb");

int pos = 8;
HuffmanTreeNode<CharInfo>* cur = root;
ch = fgetc(fIn);

while ((unsigned char)ch != EOF)
{
--pos;
if ((unsigned char)ch &(1 << pos))
{
cur = cur->_right;
}
else
{
cur = cur->_left;
}
if (cur->_left == NULL && cur->_right == NULL)
{
fputc(cur->_weight._ch, fOut);
cur = root;
Charcount--;
}
if (pos == 0)
{
ch = fgetc(fIn);
pos = 8;
}
if (Charcount == 0)
{
break;
}
}

fclose(outConfig);
fclose(fIn);
fclose(fOut);
return true;
}

protected:
string ReadLine(FILE* fConfig)
{
char ch = fgetc(fConfig);
if (ch == EOF)
{
return "";
}
string line;
while (ch != '\n' && ch != EOF)
{
line += ch;
ch = fgetc(fConfig);
}
return line;
}

void GenerateHuffmanCode()
{
HuffmanTree<CharInfo> hft;
CharInfo invalid;

hft.CreatTree(_arr, 256, invalid);
_GenerateHuffmanCode(hft.GetRootNode());
}

void _GenerateHuffmanCode(HuffmanTreeNode<CharInfo>* root)
{
if (root == NULL)
{
return;
}

_GenerateHuffmanCode(root->_left);
_GenerateHuffmanCode(root->_right);

if (root->_left == NULL && root->_right == NULL)
{
HuffmanTreeNode<CharInfo>* cur = root;
HuffmanTreeNode<CharInfo>* parent = cur->_parent;
string& code = _arr[cur->_weight._ch]._code;

while (parent)
{
if (parent->_left == cur)
{
code += '0';
}
else if (parent->_right == cur)
{
code += '1';
}
cur = parent;
parent = cur->_parent;
}

reverse(code.begin(), code.end());
}
}

private:
CharInfo _arr[256];
};

void TestFileCompress()
{

FileCompress<CharInfo> fc;
cout << "Input文件压缩中...." << endl;
cout << "压缩用时： ";
int begin1 = GetTickCount();
fc.Compress("Input");//
int end1 = GetTickCount();//
cout << end1 - begin1 << endl << endl;

cout << "Input文件解压中...." << endl;;
cout << "解压用时： ";
int begin2 = GetTickCount();
fc.UnCompresss("Input");
int end2 = GetTickCount();//用以测试解压用时
cout << end2 - begin2 << endl << endl;

FileCompress<CharInfo> fc1;

cout << "Input.BIG文件压缩中...." << endl;
cout << "压缩用时： ";
int begin3 = GetTickCount();
fc1.Compress("Input.BIG");//
int end3 = GetTickCount();//
cout << end3 - begin3 << endl << endl;

cout << "Input.BIG文件解压中...." << endl;
cout << "解压用时： ";
int begin4 = GetTickCount();
fc1.UnCompresss("Input.BIG");
int end4 = GetTickCount();
cout << end4 - begin4 << endl;
}

main函数：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include "FileCompress.h"

int main()
{
TestFileCompress();
return 0;
}

下边是项目运行结果截图：







ps：图中的比较软件为 BeyondCompare4