实验名称： :Huffman编码(二叉树应用)
Huffman编码(二叉树应用)
二、实验的目的和要求:
1.要求对文件进行Huffman编码的算法,以及对乙编码文件进行解码的算法,为简单起见,可以假设文件是存放在一个字符向量;
2.熟练掌握二叉树的应用;
3.熟练掌握计算机系统的基本操作方法,了解如何编辑、编译、链接和运行一个C++程序及二叉树上的基本运算;
4.上机调试程序,掌握查错、排错使程序能正确运行。
三、实验的环境:指硬件和软件环境
1.硬件环境:
内存1016M ， 处理器：Intel(R) Core(TM)2 Duo CPU. ，
主频：2.20GHZ
2.软件环环境：
操作系统：Windows XP Microsoft visual C++ 6.0
四、算法描述:
可用特殊符号加自然语言或算法框图(程序流程图、PAD图等)或伪语言(like C++)。
:
五、源程序清单:
主文件名：Huffman.cpp
#include"Utility.h"
#include"Lk_stack.h"
#include"Huffman.h"
void main()
{
HuffmanTree hf;
char c=0;
char answer;
while(c!='3')
{
cout<<endl<<"1.Huffman 方式 压缩.";
cout<<endl<<"2.Huffman 方式 解压.";
cout<<endl<<"3.退出.";
cout<<endl<<"请选择1/2/3:";
cin>>c;
switch(c)
{
case '1': hf.Code(); break;
case '2': hf.UnCode(); break;
}
}
}
文件名：Huffman.h
const unsigned int n=256; //字符数
const unsigned int m=256*2-1; //结点总数
struct HTNode{ //压缩用Huffman树结点
unsigned long weight; //字符频度（权值）
unsigned int parent,lchild,rchild;
};
struct Buffer{ //字节缓冲压缩用Huffman树
char ch; //字节
unsigned int bits; //实际比特数
};
class HuffmanTree{ //Huffman树
public:
void Code(); //编码
void UnCode(); //译码
private:
HTNode HT[m+1]; //树结点表(HT[1]到HT[m])
char Leaf[n+1]; //叶结点对应字符(leaf[1]到leaf[n])
char *HuffmanCode[n+1]; //叶结点对应编码(*HuffmanCode[1]到*HuffmanCode[n])
unsigned int count; //频度大于零的字符数
unsigned int char_index[n]; //字符对应在树结点表的下标(char_index[0]到char_index[n-1])
unsigned long size; //被压缩文件长度
FILE *infp,*outfp; //输入/出文件
Buffer buf; //字符缓冲
void Stat(); //统计字符出现频度并过滤掉频度为零的字符
//在HT[0]~HT[k]中选择parent为-1，树值最小的两个结点s1,s2
void Select(unsigned int k, unsigned int &s1, unsigned int &s2);
void Write(unsigned int bit); //向outfp中写入一个比特
void Write(unsigned int num,unsigned int k);//向outfp中写入k个比特
void WriteToOutfp(); //强行写入outfp
void Read(unsigned int &bit); //从infp中读出一个比特
void Read(unsigned int &num,unsigned int k);//从infp中读出k个比特
int NToBits(unsigned int num); //0~num之间的整数用二进位表示所需的最少位数
void CreateFromCodeFile(); //由编码文件中存储的树结构建立Huffman树
//由被压缩文件建立Huffman树,将树结构存入编码文件的文件头部中,并求每个字符的Huffman编码
void CreateFromSourceFile();
};
void HuffmanTree::Code() //编码
{
char infName[256],outfName[256];
cout<<"Please input source file name(size less than 4GB):"; //被压缩文件最多4GB
cin>>infName;
if((infp=fopen(infName,"rb"))==NULL){
cout<<"Can not open file:"<<infName<<endl;
exit(1);
}
if(feof(infp)!=0){
cout<<"Empty source file:"<<infName<<endl;
exit(1);
}
cout<<"Please input code file name:";
cin>>outfName;
if((outfp=fopen(outfName,"wb"))==NULL){
cout<<"Can not open file:"<<outfName<<endl;
exit(1);
}
cout<<"Pocessing..."<<endl;
unsigned char ch;
unsigned int i,c;
for(i=0;i<=n;i++)HuffmanCode[i]=NULL;
CreateFromSourceFile();
rewind(infp);
ch=fgetc(infp);
while(feof(infp)==0){
c=char_index[ch];
for(i=0;i<strlen(HuffmanCode[c]);i++){
if(HuffmanCode[c][i]=='0')Write(0);
else Write(1);
}
ch=fgetc(infp);
}
WriteToOutfp();
fclose(infp);fclose(outfp);
cout<<"Process end."<<endl<<endl;
}
void HuffmanTree::UnCode()
{
char infName[256],outfName[256];
cout<<"Please input code file name:";
cin>>infName;
if((infp=fopen(infName,"rb"))==NULL){
cout<<"Can not open file:"<<infName<<endl;
exit(1);
}
if(feof(infp)!=0){
cout<<"Empty code file:"<<infName<<endl;
exit(1);
}
cout<<"Please input target file name:";
cin>>outfName;
if((outfp=fopen(outfName,"wb"))==NULL){
cout<<"Can not open file:"<<outfName<<endl;
exit(1);
}
cout<<"Pocessing..."<<endl;
unsigned int bit,c,i;
CreateFromCodeFile(); //建立Huffman树
Read(bit);
for(i=0;i<size;i++){
c=2*count-1; //2*count-1为根结点的下标
while((HT[c].lchild!=0||HT[c].rchild!=0)&&(feof(infp)==0)){
if(bit==0)c=HT[c].lchild;
else c=HT[c].rchild;
Read(bit);
}
fputc(Leaf[c],outfp); //将字符写入outfp中
}
fclose(infp);fclose(outfp);
cout<<"Process end."<<endl<<endl;
}
void HuffmanTree::Stat() //统计字符出现频度并过滤掉频度为零的字符
{
unsigned int i,cha;
for(i=1;i<=n;i++)HT[i].weight=0;
size=0;
rewind(infp);
cha=fgetc(infp);
while(feof(infp)==0) //统计字符出现频度
{
HT[cha+1].weight++;
size++;
cha=fgetc(infp);
}
count=0;
for(cha=0;cha<n;cha++){ //过滤掉频度为零的字符
if(HT[cha+1].weight>0){
count++;
Leaf[count]=cha;
HT[count].weight=HT[cha+1].weight;
char_index[cha]=count;
}
}
}
void HuffmanTree::Select(unsigned int k, unsigned int &s1, unsigned int &s2)
{//s1,s2为权值最小的根,且s1的权值小于s2的权值
unsigned int root_count=0; //根结点数;
unsigned int root_index[n]; //根结点下标;
unsigned int tem,i,j;
for(i=1;i<=k;i++)
if(HT[i].parent==0)
root_index[root_count++]=i;
s1=root_index[0];s2=root_index[1];
if(HT[s1].weight>HT[s2].weight){
tem=s1;s1=s2;s2=tem;
}
for(i=2;i<root_count;i++){
j=root_index[i];
if(HT[j].weight<HT[s2].weight){
s2=j;
if(HT[s1].weight>HT[s2].weight){
tem=s1;s1=s2;s2=tem;
}
}
}
}
void HuffmanTree::Write(unsigned int bit) //向outfp中写入一个比特
{
buf.bits++;
buf.ch=(buf.ch<<1)+bit;
if(buf.bits==8){ //缓冲区已满,写入outfp
fputc(buf.ch,outfp);
buf.bits=0;
buf.ch=0;
}
}
void HuffmanTree::Write(unsigned int num,unsigned int k) //向outfp中写入k个比特
{
Stack<unsigned int> s;
unsigned int i,bit;
for(i=1;i<=k;i++){
s.push(num & 1);
num=(num>>1);
}
for(i=1;i<=k;i++){
s.top(bit);
Write(bit);
s.pop();
}
}
void HuffmanTree::WriteToOutfp() //强行写入outfp
{
unsigned int l=buf.bits;
if(l>0)
for(unsigned int i=0;i<8-l;i++)Write(0);
}
void HuffmanTree::Read(unsigned int &bit) //从infp中读出一个比特
{
if(buf.bits==0){
buf.ch=fgetc(infp);
buf.bits=8;
}
bit=(buf.ch & 128)>>7;
buf.ch=buf.ch<<1;
buf.bits--;
}
void HuffmanTree::Read(unsigned int &num,unsigned int k) //从infp中读出k个比特
{
unsigned int bit;
num=0;
for(unsigned int i=0;i<k;i++){
Read(bit);
num=(num<<1)+bit;
}
}
int HuffmanTree::NToBits(unsigned int num) //0~num之间的整数用二进位表示所需的位数
{
unsigned int l=0,power=1;
while(power<=num){
l++;power=power*2;
}
return l;
}
void HuffmanTree::CreateFromCodeFile() //由编码文件中存储的树结构建立Huffman树
{
buf.bits=0; //清空缓冲区
buf.ch=0;
unsigned int num,l,i;
rewind(infp);
fread(&size,sizeof(unsigned long),1,infp);
Read(count,8);
count=count+1;
for(i=1;i<=count;i++)
fread(&Leaf[i],sizeof(char),1,infp);
l=NToBits(2*count-1);
for(i=1;i<=count;i++){
HT[i].lchild=0;
HT[i].rchild=0;
}
for(i=count+1;i<=2*count-1;i++){
HT[i].lchild=(Read(num,l),num);
HT[i].rchild=(Read(num,l),num);
}
}
void HuffmanTree::CreateFromSourceFile()
//由被压缩文件建立Huffman树,将树结构存入编码文件的文件头部中,并求每个字符的Huffman编码
{
Stat();//统计字符出现频度并过滤掉频度为零的字符
//由被压缩文件建立Huffman树
unsigned int i,s1,s2;
for(i=1;i<=count;i++)HT[i].parent=HT[i].lchild=HT[i].rchild=0;
for(i=count+1;i<=2*count-1;i++){//建立Huffman树
Select(i-1,s1,s2); //选择parent为0，权值最小的两个结点s1,s2
HT[s1].parent=HT[s2].parent=i;
HT[i].parent=0;HT[i].lchild=s1;HT[i].rchild=s2;
HT[i].weight=HT[s1].weight+HT[s2].weight;
}
//将树结构存入编码文件的文件头部中
unsigned int l;
buf.bits=0; //清空缓冲区
buf.ch=0;
rewind(outfp);
fwrite(&size,sizeof(unsigned int),1,outfp);
Write(count-1,8);
for(i=1;i<=count;i++)
fwrite(&Leaf[i],sizeof(char),1,outfp);
l=NToBits(2*count-1);
for(i=count+1;i<=2*count-1;i++){
Write(HT[i].lchild,l);
Write(HT[i].rchild,l);
}
//求每个字符的Huffman编码
unsigned int start,c,f;
char *cd; //编码临时变量
for(i=1;i<=n;i++)
if(HuffmanCode[i]!=NULL){
delete []HuffmanCode[i]; //释放存储空间
HuffmanCode[i]=NULL;
}
cd=new char[count]; //分配求编码的工作空间
cd[count-1]='\0'; //编码结束符
for(i=1;i<=count;i++){ //逐位求Huffman编码
start=count-1; //编码结束符位置
for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[c].parent) //从叶到根求编码
if(HT[f].lchild==c)cd[--start]='0';
else cd[--start]='1';
HuffmanCode[i]=new char[count-start]; //为第i个字符编码分配空间
strcpy(HuffmanCode[i],&cd[start]); //从cd复制编码到HuffmanCode
}
delete []cd;
}
文件名：LK_stack.h
template<class Node_entry>
struct Node {
Node_entry entry; //数据成员
Node<Node_entry> *next;
Node(); //构造
Node(Node_entry item, Node<Node_entry> *add_on = NULL);
};
template<class Stack_entry>
class Stack {
public: // 标准栈声明方法
Stack();
bool empty() const;
Error_code push(const Stack_entry &item);
Error_code pop();
Error_code top(Stack_entry &item) const;
void clear();
~Stack();
Stack(const Stack<Stack_entry> &original);
void operator =(const Stack<Stack_entry> &original);
protected:
Node<Stack_entry> *top_node;
};
template<class Node_entry>
Node<Node_entry>::Node()
{
next = NULL;
}
template<class Node_entry>
Node<Node_entry>::Node(Node_entry item, Node<Node_entry> *add_on)
{
entry = item;
next = add_on;
}
template<class Stack_entry>
Stack<Stack_entry>::Stack()
{
top_node=NULL;
}
template<class Stack_entry>
bool Stack<Stack_entry>::empty() const
{
if(top_node==NULL)
return true;
else
return false;
}
template<class Stack_entry>
Error_code Stack<Stack_entry>::push(const Stack_entry &item)
{
Node<Stack_entry> *new_top = new Node<Stack_entry>(item, top_node);
if (new_top == NULL) return overflow;
top_node = new_top;
return success;
}
template<class Stack_entry>
Error_code Stack<Stack_entry>::pop()
{
Node<Stack_entry> *old_top = top_node;
if (top_node == NULL) return underflow;
top_node = old_top->next;
delete old_top;
return success;
}
template<class Stack_entry>
Error_code Stack<Stack_entry>::top(Stack_entry &item) const
{
if(empty())
return underflow;
else{
item=top_node->entry;
return success;
}
}
template<class Stack_entry>
void Stack<Stack_entry>::clear() // 清除栈
{
while (!empty())
pop();
}
template<class Stack_entry>
Stack<Stack_entry>::~Stack() // 析构函数 删除栈
clear();
}
template<class Stack_entry>
Stack<Stack_entry>::Stack(const Stack<Stack_entry> &original) // copy constructor
{
Node<Stack_entry> *new_copy, *original_node = original.top_node;
if (original_node == NULL) top_node = NULL;
else
{ // 复制连接结点
top_node = new_copy = new Node<Stack_entry>(original_node->entry);
while (original_node->next != NULL)
{
original_node = original_node->next;
new_copy->next = new Node<Stack_entry>(original_node->entry);
new_copy = new_copy->next;
}
}
}
template<class Stack_entry>
void Stack<Stack_entry>::operator = (const Stack<Stack_entry> &original) // Overload assignment
{
Node<Stack_entry> *new_top, *new_copy, *original_node = original.top_node;
if (original_node == NULL) new_top = NULL;
else
{
new_copy = new_top = new Node<Stack_entry>(original_node->entry);
while (original_node->next != NULL)
{
original_node = original_node->next;
new_copy->next = new Node<Stack_entry>(original_node->entry);
new_copy = new_copy->next;
}
}
while (!empty())
pop();
top_node = new_top;
}
文件名;Utility.h
#include<string.h> //standard string operations
#include<iostream.h> //standard iostream operations
#include<limits.h> //numeric limits
#include<math.h> //mathematical functions
#include<fstream.h> //file input and output
#include<ctype.h> //character classification
#include<time.h> //date and time function
#include<conio.h> //con input and output
#include<stdlib.h> //standard libray
#include<stdio.h> //standard I/O libray
enum Error_code{success,fail,underflow,overflow,range_error};
//enum bool{false,true};
六、运行结果:
实验数据压缩前形态为：we.txt内容为：we are you 123495kfj/.';'
压缩后实验数据用Microsoft Visual c++查看we.cpp:
还原后数据为ww.txt : we are you 123495kfj/.';'
由此可见程序完成了数据的无损压缩和解压。
七、实验运行情况分析(包括算法、运行结果、运行环境等问题的讨论)。
程序虽然很精简，但可以可以实现数据的压缩和解压，把一个文件压缩后，可以解压为其他的格式，所以这也可以作为一些文件的格式转换器。但是本程序也存在着不足，不能够压缩整个文件夹，当然也不能解压那些被压缩了的文件。只能解压Huffman压缩的文件。否则会出现错误。