项目：文件压缩及解压缩

项目描述：实现文件的压缩及解压缩。 

开发平台：VS2013 

开发技术：堆，Huaffman树，文件输入输出函数 

项目特点：

1.统计文件中字符出现的次数，利用数据结构堆建造Huffman树，出现次数多的编码短，出现次数少的编码长。 

2.根据建造好的Huffman树形成编码，以对文件进行压缩。

3.将文件中出现的字符以及他们出现的次数写入配置文件，以便后续的解压缩。 

4.根据配置文件读取相关信息重建Huffman树，对压缩后的文件进行译码。

项目成果：该文件压缩可将8k文件大概压缩至6k，解压缩可无错误的还原原文件。

注：由于文件较大，不易用眼睛看出原文件和解压后文件是否完全相同，这里借助软件Beyond Compare来检查两文件是否完全相同

项目代码：

FileCompress.h

#pragma once

#include<iostream>
#include<stdio.h>
#include<string>
#include "Heap.h"
#include<assert.h>

using namespace std;
template<class T>
struct HaffManTreeNode
{
HaffManTreeNode<T>* _left;
HaffManTreeNode<T>* _right;
T _weight;

HaffManTreeNode(const T& w)
:_left(NULL)
, _right(NULL)
, _weight(w)
{
}

};
struct CharInfo
{
typedef unsigned long LongType;

unsigned char _ch;
LongType _count;
string _code;

CharInfo(LongType count = 0)
:_count(count)
{}

CharInfo operator +(const CharInfo right) const
{
return CharInfo(_count + right._count);
}

bool operator !=(const CharInfo right) const
{
return _count != right._count;
}
bool operator >(const CharInfo right) const
{
return _count > right._count;
}
bool operator <(const CharInfo right) const
{
return _count < right._count;
}

};
template<class T>
class HaffManTree
{

typedef HaffManTreeNode<T> Node;
public:
HaffManTree(const T* a, size_t n, const T& invaid)
{
struct NodeCompare
{
bool operator()(Node* l, Node* r)
{
return l->_weight < r->_weight;
}
};

Heap<Node*, NodeCompare> minHeap;

for (size_t i = 0; i < n; i++)
{
if (a[i] != invaid)
{
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->_weight + right->_weight);
parent->_left = left;
parent->_right = right;
minHeap.Push(parent);
}
_root = minHeap.Top();
}

Node *GetRoot()
{
return _root;
}

protected:
Node* _root;
};

class FileCompress
{
public:
FileCompress()
{
for (int i = 0; i < 256; i++)
{
_infos[i]._ch = i;
_infos[i]._count = 0;
}
}
void Compress(string filename)
{
FILE *fout = fopen(filename.c_str(), "rb");
assert(fout);
char ch = fgetc(fout);//读取文件字符
while (ch != EOF)
{
_infos[(unsigned char)ch]._count++;
ch = fgetc(fout);
}
CharInfo invalid;
string code;
HaffManTree<CharInfo> tree(_infos, 256, invalid);//建立哈夫曼树
GenerateHaffManCode(tree.GetRoot(), code);//创建哈夫曼编码

//压缩
string compressName = filename + ".haffman";
FILE* fin = fopen(compressName.c_str(), "wb");
fseek(fout, 0, SEEK_SET);
ch = fgetc(fout);
char value = 0;
int size = 0;
while (ch != EOF)
{
string code = _infos[(unsigned char)ch]._code;
for (int i = 0; i < code.size(); i++)
{
if (code[i] == '1')
{
value |= 1;
}
++size;
if (size == 8)
{
fputc(value, fin);
value = 0;
size = 0;
}
value <<= 1;
}

ch = fgetc(fout);
}
if (size > 0)
{
value <<= 7 - size;
fputc(value, fin);
}
//写匹配文件

string configFile = filename += ".config";
FILE* fconfig = fopen(configFile.c_str(),"wb");
string line;
for (int i = 0; i < 256; i++)
{
if (_infos[i]._count>0)
{
line += _infos[i]._ch;
line += ",";
char buf[1024];
_itoa(_infos[i]._count, buf, 10);
line += buf;
line += '\n';
fputs(line.c_str(), fconfig);
}
line.clear();
}

fclose(fout);
fclose(fin);
fclose(fconfig);
}
void GenerateHaffManCode(HaffManTreeNode<CharInfo>* root, string code)
{
if (root == NULL)
return;
if (root->_left == NULL && root->_right == NULL)
{
_infos[root->_weight._ch]._code = code;
return;
}
GenerateHaffManCode(root->_left, code + '0');
GenerateHaffManCode(root->_right, code + '1');

}
bool ReadLine(FILE* fout,string& line)
{
char ch = fgetc(fout);
if (ch==EOF)
{
return false;
}
while (ch!=EOF && ch !='\n')
{
line += ch;
ch = fgetc(fout);
}
return true;
}
void UnCompress(string filename)
{
//读配置文件
string configname = filename + ".config";
FILE* fconfig = fopen(configname.c_str(),"rb");
assert(fconfig);
string line;

while(ReadLine(fconfig, line))
{
if (line.empty())
{
line += '\n';
}
else
{
unsigned char ch = line[0];
_infos[ch]._count = atoi(line.substr(2).c_str());
line.clear();
}
}
CharInfo invalid;
HaffManTree<CharInfo> tree(_infos, 256, invalid);
string compressFile = filename + ".haffman";

FILE *fout = fopen(compressFile.c_str(), "rb");
assert(fout);
string uncompress = filename += "com";
FILE *fin = fopen(uncompress.c_str(), "wb");
unsigned char ch = fgetc(fout);
int pos = 7;
HaffManTreeNode<CharInfo>* root = tree.GetRoot();
HaffManTreeNode<CharInfo>* cur = root;
int count = root->_weight._count;
while (ch != EOF)
{
if (ch & (1 << pos))
{
cur = cur->_right;
}
else
cur = cur->_left;
if (cur->_left == NULL && cur->_right == NULL)
{
fputc(cur->_weight._ch, fin);
count--;
cur = root;
}

if (pos == 0)
{
ch = fgetc(fout);
pos = 8;
}
pos--;
if (count == 0)
break;
}

fclose(fout);
fclose(fin);
fclose(fconfig);
}
protected:
CharInfo _infos[256];
};

void TestCompressFile()
{
FileCompress file;
file.Compress("input");
}
void TestUnCompressFile()
{
FileCompress file;
file.UnCompress("input");
}

堆文件：

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

// 仿函数
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 = Greater<T>>
class Heap
{
public:
Heap()
{}

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

// 建堆 N*lgN
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()
{
assert(!_a.empty());

swap(_a[0], _a[_a.size() - 1]);
_a.pop_back();

_AdjustDown(0);
}
T& Top()
{
return _a[0];
}
size_t Size()
{
return _a.size();
}

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

protected:
void _AdjustDown(size_t parent)
{
// 指向左孩子
size_t child = parent * 2 + 1;

Compare com;
while (child < _a.size())
{
// 选出左右孩子里面大的那一个

//if (child+1 < _a.size()
//	&&_a[child+1] > _a[child])
if (child + 1 < _a.size()
&& com(_a[child + 1], _a[child]))
{
++child;
}

// 如果孩子比父节点要大，则交换并继续往下调整
//if (_a[child] > _a[parent])
if (com(_a[child], _a[parent]))
{
swap(_a[child], _a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}

void _AdjustUp(int child)
{
int parent = (child - 1) / 2;
Compare com;

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

protected:
//T* _a;
//size_t _size;
//size_t _capacity;
vector<T> _a;

};

void TestHeap()
{
int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };

Heap<int, Less<int>> hp1(a, sizeof(a) / sizeof(a[0]));

hp1.Push(20);
}

template<class T>
class PriorityQueue
{
public:
// O(lgN)
void Push(const T& x)
{
_hp.Push(x);
}

// O(lgN)
void Pop()
{
_hp.Pop();
}

protected:
Heap<T> _hp;
};

void _AdjustDown(int a[], int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && a[child + 1]>a[child])
{
++child;
}

if (a[parent] < a[child])
{
swap(a[parent], a[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}

void HeapSort(int a[], size_t n)
{
assert(a);

// 建堆
for (int i = (n - 2) / 2; i >= 0; --i)
{
_AdjustDown(a, n, i);
}

// 选出一个最大数据交换到末尾，剩下数据进行向下调整
for (int i = 0; i < n; ++i)
{
swap(a[0], a[n - 1 - i]);

_AdjustDown(a, n - i - 1, 0);
}
}

void TestHeapSort()
{
int a[] = { 2, 1, 4, 5, 0, 6, 3, 7, 8, 9 };
HeapSort(a, sizeof(a) / sizeof(a[0]));
for (int i = 0; i < 10; i++)
{
cout << a[i];
}
}

测试代码：

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

int main()
{
int begin = GetTickCount();
TestCompressFile();
TestUnCompressFile();
int end = GetTickCount();

cout << "begin:" << begin << endl;
cout << "end:" << end << endl;

cout << end-begin<< endl;
cout << getchar() << endl;
return 0;
}