文件压缩与解压

文件压缩与解压思想：

 （1）统计字符出现次数，结合最小堆的性质生成哈夫曼树；

 （2）对叶节点进行编码，结点左边编0，右边编1；

 （3）读取文件，用哈夫曼编码代替字符产生新的字符，即压缩；

 （4）读取压缩文件，进行哈夫曼编码的解读产生相应字符，即解压；

例如，对以下数据生成哈夫曼树，以及产生相应的哈夫曼编码：

//自己写的最小堆（因为在加强巩固，所以没用STL里的）
#pragma once
#include<iostream>
#include<vector>
using namespace std;
template<class T>
struct Less
{
	bool operator()(const T&left, const T&right)
	{
		return left->_weight < right->_weight;
	}
};

template<class T,class Compare=Less<T>>
class Heap
{
public:
	Heap()
	{}
	Heap(const T*v, int size, int valid)
	{
		for (int i = 0; i < size; i++)
		{
			if (v[i] != valid)
				_v.push_back(v[i]);
		}
		int _size = _v.size();
		int begin = (_size - 2) / 2;
		for (int root = begin; root >= 0; root--)
		{
			AdjustDown(root);
		}
	}
	void Insert(const T& value)
	{
		_v.push_back(value);
		int leaf = _v.size() - 1;
		AdjustUp(leaf);
	}
	void Remove()
	{
		swap(_v[0], _v[_v.size() - 1]);
		_v.pop_back();
		AdjustDown(0);
	}
	T& GetTop()
	{
		if (!_v.empty())
			return _v[0];
	}
	bool Empty()
	{
		if (_v.empty())
			return true;
		return false;
	}
	int Size()
	{
		return _v.size();
	}
protected:
	void AdjustDown(int root)
	{
		size_t left = root * 2 + 1;
		size_t right = left + 1;
		int key = left;
		while (left < _v.size())
		{
			if (right < _v.size() && Compare()(_v[right], _v[left]))
				key = right;
			if (Compare()(_v[key], _v[root]))
			{
				swap(_v[key], _v[root]);
				root = key;
				left = root * 2 + 1;
				right = left + 1;
				key = left;
			}
			else
				break;
		}
	}
	void AdjustUp(int leaf)
	{
		int root = (leaf - 1) / 2;
		while (leaf > 0)
		{
			if (Compare()(_v[leaf], _v[root]))
			{
				swap(_v[leaf], _v[root]);
				leaf = root;
				root = (leaf - 1) / 2;
			}
			else
				break;
		}
	}
private:
	vector<T> _v;
};

//哈夫曼树的建立
#pragma once
#include<iostream>
#include<string>
#include"Heap.h"
using namespace std;
template<class T>
struct HuffmanTreeNode
{
	HuffmanTreeNode<T>* _left;
	HuffmanTreeNode<T>* _right;
	T _weight;
	HuffmanTreeNode(const T& weight)
		:_left(NULL)
		, _right(NULL)
		, _weight(weight)
	{}
};
template<class T>
class HuffmanTree
{
	typedef HuffmanTreeNode<T> Node;
public:
	HuffmanTree(const T*a, int size, T invaild)
	{
		_CreatHuffmanTree(a, size, invaild);
	}
	Node* GetRoot()
	{
		return _root;
	}
protected:
	void _CreatHuffmanTree(const T*a,int size,T invaild)
	{
		Heap<Node*,Less<Node*>>hp;
		for (int i = 0; i < size; i++)
		{
			if (a[i] != invaild)
				hp.Insert(new Node(a[i]));//建立小堆
		}
		//当_v中只剩下一个数据时，哈弗曼树建立完成
		while (hp.Size()>1)
		{
			Node* left = hp.GetTop();
			hp.Remove();
			Node* right = hp.GetTop();
			hp.Remove();
			Node*parent = new Node(left->_weight + right->_weight);
			parent->_left = left;
			parent->_right = right;
			hp.Insert(parent);
		}
		_root = hp.GetTop();
	}
private:
	Node* _root;
};

//文件压缩与解压
#pragma once
#include<iostream>
#include<string>
using namespace std;
#include"HuffmanTree.h"
struct CharInfo
{
	unsigned char _ch;
	long _count;
	string _code;
	CharInfo(const long count = 0)
		:_count(count)
	{}
	CharInfo(const unsigned char ch)
		:_ch(ch)
	{}
	long operator+(const CharInfo& info)const
	{
		return _count + info._count;
	}
	bool operator!=(const CharInfo& info)const
	{
		return _count != info._count;
	}
	bool operator<(const CharInfo& info)const
	{
		return _count < info._count;
	}
};
class FileCompress
{
public:
	//对文件filename进行压缩
	void Compress(const char* filename)
	{
		FILE* fread = fopen(filename, "rb");
		if (fread == NULL)
		{
			cout << "打开文件失败..." << endl;
			return;
		}
		//打开文件成功
		//1、字符与下标对应,填充结构体的_ch
		for (int i = 0; i < 256; i++)
		{
			_Info[i]._ch = i;
		}

		//2、统计各个字符出现的次数
		unsigned char ch = fgetc(fread);
		while (!feof(fread))
		{
			_Info[ch]._count++;
			ch = fgetc(fread);
		}

		//3、建立哈夫曼树
		HuffmanTree<CharInfo> hft(_Info, 256, CharInfo());

		//4、获取各个字符的哈夫曼编码
		//每次都从根节点开始，走到叶节点，即得到叶节点对应字符的编码
		HuffmanTreeNode<CharInfo>*root = hft.GetRoot();
		string code;
		GetHuffmanCodeOfChar(root, code);

	


		//5、从头开始读文件，把读取字符的编码重新组合写入压缩文件中
		fseek(fread, 0, SEEK_SET);
		//压缩产生的文件的名字
		string fcp = filename;
		fcp += ".compress";
		FILE* fwrite = fopen(fcp.c_str(), "wb");
		if (fwrite == NULL)
		{
			cout << "compress 文件打开失败" << endl;
			return;
		}

		//打开文件成功
		unsigned char data = 0;//写入压缩文件的字符
		int offset = 7;//偏移量
		ch = fgetc(fread);
		while (!feof(fread))
		{
			const char* str = _Info[ch]._code.c_str();//获取当前字符的编码
			while (*str != '\0')
			{
				if (offset >= 0)
				{
					data = data | ((*str - '0') << offset);
					offset--;
				}
				if (offset < 0)
				{
					fputc(data, fwrite);
					data = 0;
					offset = 7;
				}
				str++;
			}
			ch = fgetc(fread);
		}
		fputc(data, fwrite);
		WriteConfig(filename);
		fclose(fread);
		fclose(fwrite);
	}
	void UnCompress(const char* filename)
	{
		string fcp = filename;
		fcp += ".compress";
		FILE* fread = fopen(fcp.c_str(), "rb");
		if (fread == NULL)
		{
			cout << "打开文件失败..." << endl;
			return;
		}
		//打开文件成功
		//3、建立哈夫曼树
		CharInfo info[256];
		ReadConfig(filename, info);
		HuffmanTree<CharInfo> hft(info, 256, CharInfo());

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

		HuffmanTreeNode<CharInfo>*root = hft.GetRoot();
		HuffmanTreeNode<CharInfo>*cur = root;//每次都要从根开始读，读到叶节点即可获取一个原字符
		long DataTotal = (root->_weight)._count;//原文件中的字符总数
		unsigned char ch = fgetc(fread);
		while (DataTotal)
		{
			int tmp = 1;
			int offset = 7;
			while (offset >= 0)
			{
				if (ch&(1 << offset))//检验位是否为0
				{
					cur = cur->_right;
					offset--;
				}
				else
				{
					cur = cur->_left;
					offset--;
				}
				if (cur->_left == NULL&&cur->_right == NULL)
				{
					unsigned char wch = cur->_weight._ch;
					fputc(wch, fwrite);
					cur = root;
					DataTotal--;
					//最后一个字符的编码在最后两个字节当中的情况
					if (!DataTotal)  
					{
						break;
					}
				}
			}
			ch = fgetc(fread);
		}
		fclose(fread);
		fclose(fwrite);
	}
protected:
	void WriteConfig(const char*filename)
	{
		string Config = filename;
		Config += "config";
		FILE* fwrite = fopen(Config.c_str(), "wb");
		if (fwrite == NULL)
		{
			cout << "打开文件失败" << endl;
			return;
		}
		//打开成功
		for (int i = 0; i < 256; i++)
		{
			if (_Info[i] ._count)
			{
				fputc(_Info[i]._ch, fwrite);
				fputc(',', fwrite);
				char count[100];
				//参数说明：1.要转换的值；2.结果存放区；3.进制
				_itoa(_Info[i]._count, count, 10);
				fputs(count, fwrite);
				fputc(',', fwrite);
				fputs(_Info[i]._code.c_str(), fwrite);
				fputc('\n', fwrite);
			}
		}
		fclose(fwrite);
	}
	void ReadConfig(const char*filename,CharInfo *info)
	{
		string Config = filename;
		Config += "config";
		FILE* fread = fopen(Config.c_str(), "rb");
		if (fread == NULL)
		{
			cout << "打开文件失败" << endl;
			return;
		}
		//打开成功
		char str[100];
		while (fgets(str, 100, fread))
		{
			char*pstr = str;
			unsigned char ch = (unsigned char)*pstr;//得到字符
			info[ch]._ch = ch;
			if (ch == '\n')
			{
				fgets(str, 100, fread);
				pstr=str;
				pstr++;
			}
			else
				pstr+=2;//跳过分隔符（逗号）
			//得到_count的字符串形式
			long count = 0;
			while (*pstr&&*pstr!=',')
			{
				count *= 10;
				count += *pstr - '0';
				pstr++;
			}
			info[ch]._count = count;//得到出现次数
			pstr++;
			string code(pstr);
			info[ch]._code = code;
		}
	}
	void GetHuffmanCodeOfChar(HuffmanTreeNode<CharInfo>*root, string& code)
	{
		if (root == NULL)
			return;
		if (root->_left == NULL&&root->_right == NULL)
		{
			unsigned char ch = root->_weight._ch;
			_Info[ch]._code = code;
			return;
		}
		GetHuffmanCodeOfChar(root->_left, code + '0');//左边编码为0
		GetHuffmanCodeOfChar(root->_right, code + '1');//右边编码为1
	}

private:
	CharInfo _Info[256];//结构体数组
};