数据结构课程设计报告基于哈夫曼树的文件压缩/解压程序专业班级：信科（2）班
姓名：徐爱娟谢静
学号：20101614310051
20101614310050
2012-12_31
一需求分析
1.课题要求（实现文件的压缩与解压并计算压缩率）
A.描述压缩基本符号的选择方法
B.运行时压缩原文件的规模应不小于5K
2.设计目标
A软件名称：基于哈夫曼编码的文件压缩实用程序系统
B软件组成：huffman.exe
C制作平台及相关调试工具：
Windows XP sp3 Microsoft Visual C++ 6.0
D运行环境：dos/ win2K/win2003/winxp/
E性能特点：
1.软件由一个可执行文件组成
huffman.exe为dos系统应用程序，体积小，高效快捷，适用范围广。
2. 对单字节（256叶子）进行哈夫曼编码，压缩率良好
3. 使用二级缓冲压缩/解压技术，速度比一般算法高
4. 可压缩最大体积为4G的文件，达到Fat32文件系统极限
5. 文件索引体积比常规算法小50%
二概要设计
1.相关函数介绍
1. bool InitFromFile(string fileadd) 从文件中初始化哈夫曼树函数
2. void HTCreat(HTNode ht[],int n) 构造哈夫曼树函数
3. void HCCreat(HTNode ht[],HCode hcd[],int n) 构造哈夫曼编码函数
4. void ConvertFile(HCode hcd[],string fileadd,string fileadd2) 压缩and写入文件函数
5. void DecompressionFile(string fileadd2,string fileadd3) 文件解压函数
6. string Compression(string fileadd) 压缩函数
7. string Decompression(string fileadd2) 解压函数
三详细设计
1压缩算法部分
A核心算法：
Huffman编码是一种可变长编码方式，是由美国数学家David Huffman创立的，是二叉树的一种特殊转化形式。编码的原理是：将使用次数多的代码转换成长度较短的代码，而使用次数少的可以使用较长的编码，并且保持编码的唯一可解性。Huffman算法的最根本的原则是：累计的(字符的统计数字*字符的编码长度)为最小，也就是权值(字符的统计数字*字符的编码长度)的和最小。
B哈夫曼树构造算法：
Huffman树是二叉树的一种特殊转化形式。以下是构件Huffman树的例子：比如有以下数据， ABFACGCAHGBBAACECDFGFAAEABBB先进行统计
G(3) H(1) 括号里面的是统计次数
生成Huffman树：每次取最小的那两个节点(node)合并成一个节点(node)，并且将累计数值相加作为新的接点的累计数值，最顶层的是根节点(root) 注：列表中最小节点的是指包括合并了的节点在内的所有节点，已经合并的节点不在列表中
运算的过程如下：
1:D+H(2)
2:DE+H(4)
3:F+G(6)
4:C+DEH(8)
5:B+FG(12)
6:A+CDEH(16)
7:ACDEH+BFG(28)
那么转化为Huffman树就是
Huffman树层数
Root
┌┴┐
ACDEH BFG 1
┌┴┐┌┴┐
CDEH A B FG 2
┌┴┐┌┴┐
DEH C F G 3
┌┴┐
DH E 4
┌┴┐
D H 5
取左面是1 右面是0 则有。
注：层数就是位数或者说是代码长度，权值=代码长度*该字的统计次数。
代码位数权值
A = 10 2 16
B = 01 2 12
C = 110 3 12
D = 11111 5 5
E = 1110 4 8
F = 001 3 9
G = 000 2 6
H = 11110 5 5
可以看出Huffman代码是唯一可解的(uniquely decodable)，如果你读到110就一定是C ，不会有任何一个编码是以110开始的。
如果不使用Huffman算法，而使用普通的编码，结果是什么呢？
Huffman树层数
Root
┌┴┐
ABCD EFGH 1
┌┴┐┌┴┐
AB CD EF GH 2
┌┴┐┌┴┐┌┴┐┌┴┐
A B C D E F G H 3
取左面是1 右面是0 则有
代码位数权值
A = 111 3 24
B = 110 3 18
C = 101 3 12
D = 100 3 3
E = 011 3 6
F = 010 3 9
G = 001 3 9
H = 000 3 3
利用Huffman编码得到的权值累计是 73，如果利用普通定长编码的话，则要用84字符长度。从这个比较，可以看出，Huffman是怎么进行压缩的。
C哈夫曼编码结构及算法
编码：将ABCDEFGH用Huffman树产生的编码对应着写到文件中，并且保留原始的Huffman树，主要是编码段的信息。一般要编码256个元素的话需要511个单位来储存Huffman树，每个Huffman树都必须有以下的结构：code,char,left,right,probability(出现次数)，通常情况是利用一个数组结构。因为在解码的时候只需要用到code，所以只需要记录每个元素的编码就可以了。
解码：利用文件中保存的Huffman编码，一一对应，解读编码，把可变长编码转换为定长编码。
2．解压缩算法部分
A.基于字符匹配的解压算法
读出结点数就能知道哈夫曼树存入部分的总长，方便读出树哈夫曼树（子结点值和权值），就能由次些信息重新构造完整的哈夫曼树，和各结点的哈夫曼编码。解压时，读取一个字节（8 bit）用一个函数转换为8个字符（用一个数组记录，其元素只是一个0或一个1），然后按哈夫曼树从顶向下查找，如果到达叶子结点，就读出该叶子结点的值，放入缓冲区中，如果不是，则继续找，如此重复，直到缓冲区满了，就写入到解压文件中，再循环以上过程，直到处理完所有数据。
B.缓冲输入输出
和压缩时采用1M二级缓冲相同，如果的压缩时也采用此技术，也会有很大的速度优化，当然程序也变得更加复杂。
四用户使用说明
1.运行huffman.exe程序，出现下面的界面
2.选择相应的功能，输入正确文件路径，对文件进行压缩、解压。
五设计心得体会
通过这次课题实验的程序实践，我实在获益匪浅！数据结构是本学期开展的一门学科，学习好这门学科是非常重要的，在以后的程序设计方面这门学科能给我们很大的帮助。同时，学习这门学科也是艰辛的，因为它比较难懂，这不仅需要我们要发挥我们的聪明才志，还需要我们在不断的实践中领悟。
六附录
程序清单
在此，给出huffman.exe的程序清单。
#include
#include
#include
#include
using namespace std;
struct HTNode
{
char data; //节点数据
int weight; //权值
int parent; //父亲
int leftchild; //左孩子
int rightchild; //右孩子
};
typedef char* Code;
HTNode *ht;
Code *hcd;
int maplist[256]; //建立字符与哈夫曼编码的映射
int nodenum=0; //哈夫曼树结点数
int rearnum=0; //哈夫曼编码尾补码
int textlen=0; //需压缩的文件长度
int codelen=0; //压缩后的文件的哈夫曼编码总长度
int const bufferlen=1024; //设置读取缓冲区长度
int clean(); //清空节点及编码指针内容
void dtobin(int num,int bin[8]); //十进制变换成二进制
void HTCreate(HTNode ht[],int n); //建立哈夫曼树
void HCCreat(HTNode ht[],Code hcd[],int n); //提取哈夫曼编码
void WriteFile(char *tmp); //写入文件
unsigned char ConvertBinary(char *tmp); //变换二进制文件
void ConvertFile(Code hcd[],string fileadd,string fileadd2); //压缩并解压文件bool InitFromFile(string fileadd); //初始化文件
void DecompressionFile(string fileadd2,string fileadd3); //解压文件
string Compression(string fileadd); //压缩文件
string Decompression(string fileadd2); //解压文件子函数
///////////////十进制转二进制函数/////////////////
int clean()
{
delete[] ht;
delete[] hcd;
return 1;
}
void dtobin(int num,int bin[8])
{
int i=0;
for(i=0;i<8;i++)
{
bin[i]=0;
}
i=0;
while(num>0)
{
bin[8-1-i]=num%2;
num=num/2;
i++;
}
}
//////////////////压缩和写入文件//////////////////
void ConvertFile(Code hcd[],string fileadd,string fileadd2)
{
fstream infile(fileadd.c_str(),ios::in|ios::binary);
fstream outfile(fileadd2.c_str(),ios::out|ios::binary);
if(!infile) cout<<"open file fail!"< if(!outfile) cout<<"creat file fail!"< //unsigned char ch; /////////////写入哈夫曼树////////////// ch=nodenum; outfile.write(&ch,1); ///写入结点数 ch=8; outfile.write(&ch,1); ///写入补位数(预写入) codelen=0; outfile.write((char *)&codelen,4); //写入压缩后的文件的哈夫曼编码总长度(预写入) int h=0; for(h=0;h { outfile.write((char*)&ht[h].data,sizeof(char)); outfile.write((char*)&ht[h].weight,sizeof(int)); } char tmp[8]; //设置缓冲区 char outbuffer[bufferlen]; //设置写入缓冲区 char *tmpcd; int i=0,j,k,last=0; char inbuffer[bufferlen]; int readlen=0; //infile.seekg(i,ios::beg); h=0; do { infile.read(inbuffer,bufferlen); readlen=infile.gcount(); tmpcd=hcd[maplist[(unsigned char)inbuffer[i]]]; for(i=0;i { for(j=last;j<8 && *tmpcd!='\0';j++) { tmp[j]=*tmpcd; tmpcd++; } if(j==8 && *tmpcd=='\0') { last=0; i++; ch=ConvertBinary(tmp); //cout<<':'<<(unsigned int)ch<<' '; outbuffer[h]=ch; h++; codelen++; //压缩文件长度加一 if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } if(i else { i=0; break; } } else if(j<8 && *tmpcd=='\0') { last=j; i++; if(i else { i=0; break; } /////继续循换//// } else if(j==8 && *tmpcd!='\0') { last=0; //WriteFile(tmp); ch=ConvertBinary(tmp); outbuffer[h]=ch; h++; codelen++; //压缩文件长度加一 if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } } } } while(readlen==bufferlen); if(j==8 && readlen { outfile.write(outbuffer,h); } else if(j<8 && readlen { for(k=j;k<8;k++) { tmp[k]='0'; } ch=ConvertBinary(tmp); outbuffer[h]=ch; h++; outfile.write(outbuffer,h); codelen++; //压缩文件长度加一 } cout< ch=8-j; rearnum=8-j; outfile.seekp(1,ios::beg); outfile.write(&ch,1); //写入真正的补位数 outfile.seekp(2,ios::beg); outfile.write((char*)&codelen,4); //写入真正的压缩后的文件的哈夫曼编码总长度长度outfile.close(); infile.close(); } //////////////构造哈夫曼树//////////// void HTCreate(HTNode ht[],int n) { int i,k,lnode,rnode; int min1,min2; for(i=0;i<2*n-1;i++) { ht[i].parent=ht[i].rightchild=ht[i].leftchild=-1; } for(i=n;i<2*n-1;i++) { min1=min2=2147483647; lnode=rnode=-1; for(k=0;k<=i-1;k++) { if(ht[k].parent==-1) { if(ht[k].weight { min2=min1; min1=ht[k].weight; rnode=lnode; lnode=k; } else if(ht[k].weight { min2=ht[k].weight; rnode=k; } } } ht[lnode].parent=i; ht[rnode].parent=i; ht[i].weight=ht[lnode].weight+ht[rnode].weight; ht[i].leftchild=lnode; ht[i].rightchild=rnode; } } ///////////构造哈夫曼编码///////////// void HCCreat(HTNode ht[],Code hcd[],int n) { int i,p,c; Code hc; hc=new char[n]; int start,tmplen; for(i=0;i { tmplen=0; start=n-1; hc[start]='\0'; c=i; p=ht[i].parent; while(p!=-1) { if(ht[p].leftchild==c) //是左孩子结点 { hc[--start]='0'; tmplen++; } else { hc[--start]='1'; tmplen++; } c=p; p=ht[p].parent; } hcd[i]=new char[n-start]; strcpy(hcd[i],&hc[start]); } delete[] hc; } void WriteFile(char *tmp) { int i; for(i=0;i<8;i++) cout< cout<<' '; tmp=""; } unsigned char ConvertBinary(char *tmp) { char ch=0; int i; for(i=0;i<8;i++) { ch=(unsigned char)pow(2.0,8-i-1)*(tmp[i]-48)+ch; } return ch; } //////////////打开文件////////////// bool InitFromFile(string fileadd) { fstream infile(fileadd.c_str(),ios::binary|ios::in); if(!infile){cout<<"error!"< int table[256]; int i,j; int len=0,num=0; unsigned char ch; for(i=0;i<256;i++) {table[i]=0;maplist[i]=-1;} int readlen=0; char buffer[bufferlen]; //设置读取缓冲区,加快读取速度do { infile.read(buffer,bufferlen); i=0; readlen=infile.gcount(); while(i { ch=(unsigned char)buffer[i]; table[ch]++; len++; i++; } } while(readlen==bufferlen); for(i=0;i<256;i++) { if(table[i]!=0) num++; } ht=new HTNode[2*num-1]; hcd=new Code[num]; for(i=0,j=0;i<256;i++) { if(table[i]!=0) { ht[j].data=i; ht[j].weight=table[i]; maplist[i]=j; //建立字符与哈夫曼编码的映射 j++; } } nodenum=num; textlen=len; infile.clear(); infile.close(); return 1; } /////////////从文件解压//////////////////// void DecompressionFile(string fileadd2,string fileadd3) { //cout<<"............解压并输出新文件过程:"< fstream infile(fileadd2.c_str(),ios::in|ios::binary); fstream outfile(fileadd3.c_str(),ios::out|ios::binary); cout< /////////////////读出哈夫曼树的数据///////////// int h=0; char buffer[bufferlen]; //读入文件的缓冲区 char outbuffer[bufferlen]; //写入文件的缓冲区 infile.read(buffer,1); nodenum=(unsigned char)*buffer;//哈夫曼树结点数 if(nodenum==0) nodenum=256; infile.read(buffer,1); rearnum=(unsigned char)*buffer; infile.read((char*)&codelen,4); //cout<<" 读出哈夫曼树数据...."< ht=new HTNode[2*nodenum-1]; hcd=new Code[nodenum]; //hcdlen=new int[nodenum]; for(h=0;h { infile.read(&ht[h].data,1); infile.read((char*)&ht[h].weight,4); } //////构走哈夫曼树/////// HTCreate(ht,nodenum); //////构造哈夫曼编码///// HCCreat(ht,hcd,nodenum); ///////////////////////解压并输出解压文件//////////////////////// char *buffertmp=new char; int bin[8],j=0,i=0; int coderead=0; //记录以度的长度,用于判断何时达到文件最后一字节(用codelen比较) int readlen=0; int child=0; int last=2*nodenum-2; //解压时记录上次指示器的位置 child=last; unsigned char outp; h=0; do { infile.read(buffer,bufferlen); readlen=infile.gcount(); for(j=0;j { coderead++; outp=buffer[j]; dtobin(outp,bin); if(coderead==codelen) //达到文件尾 { for(i=0;i<=8-rearnum;i++) { if(ht[child].leftchild==-1 && ht[child].rightchild==-1) { //cout< outbuffer[h]=ht[child].data; h++; if(h==bufferlen) {outfile.write(outbuffer,bufferlen);h=0;} last=2*nodenum-2; if(i==8-rearnum) { if(h!=0) outfile.write(outbuffer,h); child=last; break; } else i--; } else if(i!=8) { if(bin[i]==0) last=ht[child].leftchild; else if(bin[i]==1) last=ht[child].rightchild; } child=last; } } else //没达到文件尾 { for(i=0;i<=8;i++) { if(ht[child].leftchild==-1 && ht[child].rightchild==-1) { //cout< outbuffer[h]=ht[child].data; h++; if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } last=2*nodenum-2; if(i==8) { child=last; break; } else i--; } else if(i!=8) { if(bin[i]==0) last=ht[child].leftchild; else if(bin[i]==1) last=ht[child].rightchild; } child=last; } } } } while(readlen==bufferlen); //cout< infile.close(); outfile.close(); } string Compression(string fileadd) { int i; for(i=0;i if(fileadd[i]=='\\') fileadd[i]='/'; string fileadd2; fileadd2=fileadd+".rax"; InitFromFile(fileadd); //从文件中初始化哈夫曼树 HTCreate(ht,nodenum); //构造哈夫曼树 HCCreat(ht,hcd,nodenum); //构造哈夫曼编码 ConvertFile(hcd,fileadd,fileadd2); //压缩并写入文件 clean(); return fileadd2; } string Decompression(string fileadd2) { int i; for(i=0;i if(fileadd2[i]=='\\') fileadd2[i]='/'; string fileclass; string fileadd3; for(i=fileadd2.length()-5;fileadd2[i]!='.' && i>0;i--) fileclass.insert(0,fileadd2.substr(i,1)); if(i!=0) fileadd3=fileadd2.substr(0,i)+"_"+'.'+fileclass; else fileadd3=fileadd2.substr(0,fileadd2.length()-4)+"_"; DecompressionFile(fileadd2,fileadd3); clean(); return fileadd3; } int main() { cout<<"缓冲区长度:"< cout<<"\t*******************************************************\n"; cout<<"\t* *\n"; cout<<"\t* 数据结构课程设计*\n"; cout<<"\t* 基于哈夫曼的文件压缩解压程序*\n"; cout<<"\t* *\n"; cout<<"\t*******************************************************\n"; string fileadd; string fileadd2; char usage; do { cout<<""< cout<<"(1)压缩C"< cout<<"(2)解压D"< cout<<"(3)退出Q "< cout<<""< cout<<"*请输入选项:"; cin>>usage; if(usage=='C' || usage=='c') { cout<<"请输入压缩文件的路径:"; cin>>fileadd; cout<<"压缩文件开始..."; fileadd2=Compression(fileadd); cout<<"压缩文件完毕,压缩后文件的路径是:"< } else if(usage=='D' || usage=='d') { cout<<"请输入解压文件的路径:"; cin>>fileadd; cout<<"解压文件开始..."; fileadd2=Decompression(fileadd); cout<<"解压文件完毕,解压后文件的路径是:"< } else if(usage=='Q' || usage=='q') return 0; } while(1); return 0; } #include #include #include #include using namespace std; struct HTNode { char data; //节点数据 int weight; //权值 int parent; //父亲 int leftchild; //左孩子 int rightchild; //右孩子 }; typedef char* Code; HTNode *ht; Code *hcd; int maplist[256]; //建立字符与哈夫曼编码的映射 int nodenum=0; //哈夫曼树结点数 int rearnum=0; //哈夫曼编码尾补码 int textlen=0; //需压缩的文件长度 int codelen=0; //压缩后的文件的哈夫曼编码总长度 int const bufferlen=1024; //设置读取缓冲区长度 int clean(); //清空节点及编码指针内容 void dtobin(int num,int bin[8]); //十进制变换成二进制 void HTCreate(HTNode ht[],int n); //建立哈夫曼树 void HCCreat(HTNode ht[],Code hcd[],int n); //提取哈夫曼编码 void WriteFile(char *tmp); //写入文件 unsigned char ConvertBinary(char *tmp); //变换二进制文件 void ConvertFile(Code hcd[],string fileadd,string fileadd2); //压缩并解压文件bool InitFromFile(string fileadd); //初始化文件 void DecompressionFile(string fileadd2,string fileadd3); //解压文件 string Compression(string fileadd); //压缩文件 string Decompression(string fileadd2); //解压文件子函数 ///////////////十进制转二进制函数///////////////// int clean() { delete[] ht; delete[] hcd; return 1; } void dtobin(int num,int bin[8]) { int i=0; for(i=0;i<8;i++) { bin[i]=0; } i=0; while(num>0) { bin[8-1-i]=num%2; num=num/2; i++; } } //////////////////压缩和写入文件////////////////// void ConvertFile(Code hcd[],string fileadd,string fileadd2) { //////////////////////////////////////// fstream infile(fileadd.c_str(),ios::in|ios::binary); fstream outfile(fileadd2.c_str(),ios::out|ios::binary); if(!infile) cout<<"open file fail!"< if(!outfile) cout<<"creat file fail!"< //unsigned char ch; /////////////写入哈夫曼树////////////// ch=nodenum; outfile.write(&ch,1); ///写入结点数 ch=8; outfile.write(&ch,1); ///写入补位数(预写入) codelen=0; outfile.write((char *)&codelen,4); //写入压缩后的文件的哈夫曼编码总长度(预写入) int h=0; for(h=0;h { outfile.write((char*)&ht[h].data,sizeof(char)); outfile.write((char*)&ht[h].weight,sizeof(int)); } char tmp[8]; //设置缓冲区 char outbuffer[bufferlen]; //设置写入缓冲区 char *tmpcd; int i=0,j,k,last=0; char inbuffer[bufferlen]; int readlen=0; //infile.seekg(i,ios::beg); h=0; do { infile.read(inbuffer,bufferlen); readlen=infile.gcount(); tmpcd=hcd[maplist[(unsigned char)inbuffer[i]]]; for(i=0;i { for(j=last;j<8 && *tmpcd!='\0';j++) { tmp[j]=*tmpcd; tmpcd++; } if(j==8 && *tmpcd=='\0') { last=0; i++; ch=ConvertBinary(tmp); //cout<<':'<<(unsigned int)ch<<' '; outbuffer[h]=ch; h++; codelen++; //压缩文件长度加一 if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } if(i else { i=0; break; } } else if(j<8 && *tmpcd=='\0') { last=j; i++; if(i else { i=0; break; } /////继续循换//// } else if(j==8 && *tmpcd!='\0') { last=0; //WriteFile(tmp); ch=ConvertBinary(tmp); outbuffer[h]=ch; h++; codelen++; //压缩文件长度加一 if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } } } } while(readlen==bufferlen); if(j==8 && readlen { outfile.write(outbuffer,h); } else if(j<8 && readlen { for(k=j;k<8;k++) { tmp[k]='0'; } ch=ConvertBinary(tmp); outbuffer[h]=ch; h++; outfile.write(outbuffer,h); codelen++; //压缩文件长度加一 } cout< ch=8-j; rearnum=8-j; outfile.seekp(1,ios::beg); outfile.write(&ch,1); //写入真正的补位数 outfile.seekp(2,ios::beg); outfile.write((char*)&codelen,4); //写入真正的压缩后的文件的哈夫曼编码总长度长度outfile.close(); infile.close(); } //////////////构造哈夫曼树//////////// void HTCreate(HTNode ht[],int n) { int i,k,lnode,rnode; int min1,min2; for(i=0;i<2*n-1;i++) { ht[i].parent=ht[i].rightchild=ht[i].leftchild=-1; } for(i=n;i<2*n-1;i++) { min1=min2=2147483647; lnode=rnode=-1; for(k=0;k<=i-1;k++) { if(ht[k].parent==-1) { if(ht[k].weight { min2=min1; min1=ht[k].weight; rnode=lnode; lnode=k; } else if(ht[k].weight { min2=ht[k].weight; rnode=k; } } } ht[lnode].parent=i; ht[rnode].parent=i; ht[i].weight=ht[lnode].weight+ht[rnode].weight; ht[i].leftchild=lnode; ht[i].rightchild=rnode; } } ///////////构造哈夫曼编码///////////// void HCCreat(HTNode ht[],Code hcd[],int n) { int i,p,c; Code hc; hc=new char[n]; int start,tmplen; for(i=0;i { tmplen=0; start=n-1; hc[start]='\0'; c=i; p=ht[i].parent; while(p!=-1) { if(ht[p].leftchild==c) //是左孩子结点 { hc[--start]='0'; tmplen++; } else { hc[--start]='1'; tmplen++; } c=p; p=ht[p].parent; } hcd[i]=new char[n-start]; strcpy(hcd[i],&hc[start]); } delete[] hc; } void WriteFile(char *tmp) { int i; for(i=0;i<8;i++) cout< cout<<' '; tmp=""; } unsigned char ConvertBinary(char *tmp) { char ch=0; int i; for(i=0;i<8;i++) { ch=(unsigned char)pow(2.0,8-i-1)*(tmp[i]-48)+ch; } return ch; } //////////////打开文件////////////// bool InitFromFile(string fileadd) { fstream infile(fileadd.c_str(),ios::binary|ios::in); if(!infile){cout<<"error!"< int table[256]; int i,j; int len=0,num=0; unsigned char ch; for(i=0;i<256;i++) {table[i]=0;maplist[i]=-1;} int readlen=0; char buffer[bufferlen]; //设置读取缓冲区,加快读取速度do { infile.read(buffer,bufferlen); i=0; readlen=infile.gcount(); while(i { ch=(unsigned char)buffer[i]; table[ch]++; len++; i++; } } while(readlen==bufferlen); for(i=0;i<256;i++) { if(table[i]!=0) num++; } ht=new HTNode[2*num-1]; hcd=new Code[num]; for(i=0,j=0;i<256;i++) { if(table[i]!=0) { ht[j].data=i; ht[j].weight=table[i]; maplist[i]=j; //建立字符与哈夫曼编码的映射 j++; } } nodenum=num; textlen=len; infile.clear(); infile.close(); return 1; } /////////////从文件解压//////////////////// void DecompressionFile(string fileadd2,string fileadd3) { //cout<<"............解压并输出新文件过程:"< fstream infile(fileadd2.c_str(),ios::in|ios::binary); fstream outfile(fileadd3.c_str(),ios::out|ios::binary); cout< /////////////////读出哈夫曼树的数据///////////// int h=0; char buffer[bufferlen]; //读入文件的缓冲区 char outbuffer[bufferlen]; //写入文件的缓冲区 infile.read(buffer,1); nodenum=(unsigned char)*buffer;//哈夫曼树结点数 if(nodenum==0) nodenum=256; infile.read(buffer,1); rearnum=(unsigned char)*buffer; infile.read((char*)&codelen,4); //cout<<" 读出哈夫曼树数据...."< ht=new HTNode[2*nodenum-1]; hcd=new Code[nodenum]; //hcdlen=new int[nodenum]; for(h=0;h { infile.read(&ht[h].data,1); infile.read((char*)&ht[h].weight,4); } //////构走哈夫曼树/////// HTCreate(ht,nodenum); //////构造哈夫曼编码///// HCCreat(ht,hcd,nodenum); ///////////////////////解压并输出解压文件//////////////////////// char *buffertmp=new char; int bin[8],j=0,i=0; int coderead=0; //记录以度的长度,用于判断何时达到文件最后一字节(用codelen比较) int readlen=0; int child=0; int last=2*nodenum-2; //解压时记录上次指示器的位置 child=last; unsigned char outp; h=0; do { infile.read(buffer,bufferlen); readlen=infile.gcount(); for(j=0;j { coderead++; outp=buffer[j]; dtobin(outp,bin); if(coderead==codelen) //达到文件尾 { for(i=0;i<=8-rearnum;i++) { if(ht[child].leftchild==-1 && ht[child].rightchild==-1) { //cout< outbuffer[h]=ht[child].data; h++; if(h==bufferlen) {outfile.write(outbuffer,bufferlen);h=0;} last=2*nodenum-2; if(i==8-rearnum) { if(h!=0) outfile.write(outbuffer,h); child=last; break; } else i--; } else if(i!=8) { if(bin[i]==0) last=ht[child].leftchild; else if(bin[i]==1) last=ht[child].rightchild; } child=last; } } else //没达到文件尾 { for(i=0;i<=8;i++) { if(ht[child].leftchild==-1 && ht[child].rightchild==-1) { //cout< outbuffer[h]=ht[child].data; h++; if(h==bufferlen) { outfile.write(outbuffer,bufferlen); h=0; } last=2*nodenum-2; if(i==8) { child=last; break; } else i--; } else if(i!=8) { if(bin[i]==0) last=ht[child].leftchild; else if(bin[i]==1) last=ht[child].rightchild; } child=last; } } } } while(readlen==bufferlen); //cout< infile.close(); outfile.close(); } string Compression(string fileadd) { int i; for(i=0;i if(fileadd[i]=='\\') fileadd[i]='/'; string fileadd2; fileadd2=fileadd+".rax"; InitFromFile(fileadd); //从文件中初始化哈夫曼树 HTCreate(ht,nodenum); //构造哈夫曼树 HCCreat(ht,hcd,nodenum); //构造哈夫曼编码 ConvertFile(hcd,fileadd,fileadd2); //压缩并写入文件 clean(); return fileadd2; } string Decompression(string fileadd2) { int i; for(i=0;i if(fileadd2[i]=='\\') fileadd2[i]='/'; string fileclass; string fileadd3; for(i=fileadd2.length()-5;fileadd2[i]!='.' && i>0;i--) fileclass.insert(0,fileadd2.substr(i,1)); if(i!=0) fileadd3=fileadd2.substr(0,i)+"_"+'.'+fileclass; else fileadd3=fileadd2.substr(0,fileadd2.length()-4)+"_"; DecompressionFile(fileadd2,fileadd3); clean(); return fileadd3; } int main() { cout<<"缓冲区长度:"< cout<<"\t*******************************************************\n"; cout<<"\t* *\n"; cout<<"\t* 数据结构课程设计*\n"; cout<<"\t* 基于哈夫曼的文件压缩解压程序*\n"; cout<<"\t* *\n"; cout<<"\t*******************************************************\n"; string fileadd; string fileadd2; char usage; do { cout<<""< cout<<"(1)压缩C"< cout<<"(2)解压D"< cout<<"(3)退出Q "< cout<<""< cout<<"*请输入选项:"; cin>>usage; if(usage=='C' || usage=='c') { cout<<"请输入压缩文件的路径:"; cin>>fileadd; cout<<"压缩文件开始..."; fileadd2=Compression(fileadd); cout<<"压缩文件完毕,压缩后文件的路径是:"< } else if(usage=='D' || usage=='d') { cout<<"请输入解压文件的路径:"; cin>>fileadd; cout<<"解压文件开始..."; fileadd2=Decompression(fileadd); cout<<"解压文件完毕,解压后文件的路径是:"< } else if(usage=='Q' || usage=='q') return 0; } while(1); return 0; } v .. . .. 安徽大学 数据结构课程设计报告项目名称：哈弗曼编/译码系统的设计 与实现 姓名：鉏飞祥 学号：E21414018 专业：软件工程 完成日期 2016/7/4 计算机科学与技术学院 1 .需求分析 1.1问题描述 ?问题描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。 1.2基本要求 (1)输入的形式和输入值的范围； (2)输出的形式； (3)程序所能达到的功能。 1.基本要求 （1）初始化（Initialzation）。从数据文件DataFile.data中读入字符及每个字符的权值，建立哈夫曼树HuffTree； （2）编码（EnCoding）。用已建好的哈夫曼树，对文件ToBeTran.data中的文本进行编码形成报文，将报文写在文件Code.txt中； （3）译码（Decoding）。利用已建好的哈夫曼树，对文件CodeFile.data中的代码进行解码形成原文，结果存入文件Textfile.txt中； （4）输出（Output）。输出DataFile.data中出现的字符以及各字符出现的频度（或概率）；输出ToBeTran.data及其报文Code.txt；输出CodeFile.data 及其原文Textfile.txt； 2. 概要设计 说明本程序中用到的所有抽象数据类型的定义。主程序的流程以及各程序模块之间的层次(调用)关系。 (1)数据结构 哈夫曼树的节点 struct huff { int weight; int parent; int l; int r; }; 哈夫曼编码的存储 struct huff *hufftree; (2)程序模块 选择1到i-1中parent为0且权值最小的两个下标 void Select(struct huff *HT, int n, int &s1, int &s2) 构建哈夫曼树： void huffmancoding(struct huff *ht,int *w,int n) 兰州商学院陇桥学院 工学系课程设计报告 设计题目：哈夫曼（huffman）编译码器系别： 专业 (方向)： 年级、班： 学生姓名： 学生学号： 指导教师： 年月日 目录 哈夫曼(huffman )编译码器 (3) 一、编译码器开发的背景 (3) 二、系统的分析与设计 (3) （一）系统功能要求 (3) （二）系统模块结构设计 (4) 三、系统的设计与实现 (6) （一）main() (6) （二）运算 (7) 1. 权值运算quanzhi() (7) 2. 印二叉树函数huffmantree( ) (7) 3.编译码运算huffmancode() (9) 4. 输出运算 shuchu() (9) 四、系统测试 (10) （一）测试主函数 (10) （二）测试印二叉树函数 (10) （三）测试译码运算函数 (11) 五、总结 (12) 六、附件（代码、部分图表） (13) 哈夫曼(huffman )编译码器 一、编译码器开发的背景 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。 二、系统的分析与设计 （一）系统功能要求 一个完整的系统应具有以下功能： 1)I：初始化（Initialization）。从终端读入字符集大小n，以 及n个字符和n个权值，建立哈夫曼树，并将它存于文件 hfmTree中。 2)E：编码（Encoding）。利用以建好的哈夫曼树（如不在内存， 则从文件hfmTree中读入），对文件ToBeTran中的正文进行编 码，然后将结果存入文件CodeFile中。 3)D：译码（Decoding）。利用已建好的哈夫曼树将文件CodeFile 中的代码进行译码，结果存入文件TextFile中。 4)P：印代码文件（Print）。将文件CodeFile以紧凑格式显示在 JAVA语言实验报告 学院计算机工程学院班级计算1013 姓名 xxxx 学号 201081xxxx 成绩指导老师 xxxx 2012年09月03日 目录 目录 (1) 1 课程设计的目的和意义 (2) 2 需求分析 (3) 3 系统（项目）设计 (5) ①设计思路及方案 (5) ②模块的设计及介绍 (5) ③主要模块程序流程图 (8) 4 系统实现 (11) ①主调函数 (12) ②建立HuffmanTree (12) ③生成Huffman编码并写入文件 (15) ④电文译码 (16) 5 系统调试 (17) 参考文献 (21) 附录源程序 (22) 1 课程设计的目的和意义 在当今信息爆炸时代，如何采用有效的数据压缩技术来节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视。哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。 哈夫曼编码的应用很广泛，利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。树中从根到每个叶子都有一条路径，对路径上的各分支约定：指向左子树的分支表示“0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或“1”的序列作为和各个对应的字符的编码，这就是哈夫曼编码。 通常我们把数据压缩的过程称为编码，解压缩的过程称为解码。电报通信是传递文字的二进制码形式的字符串。但在信息传递时，总希望总长度尽可能最短，即采用最短码。 作为信息管理专业的学生，我们应该很好的掌握这门技术。在课堂上，我们能过学到许多的理论知识，但我们很少有过自己动手实践的机会！课程设计就是为解决这个问题提供了一个平台。 在课程设计过程中，我们每个人选择一个课题，认真研究，根据课堂讲授内容，借助书本，自己动手实践。这样不但有助于我们消化课堂所讲解的内容，还可以增强我们的独立思考能力和动手能力；通过编写实验代码和调试运行，我们可以逐步积累调试C程序的经验并逐渐培养我们的编程能力、用计算机解决实际问题的能力。 在课程设计过程中，我们不但有自己的独立思考，还借助各种参考文献来帮助我们完成系统。更为重要的是，我们同学之间加强了交流，在对问题的认识方面可以交换不同的意见。同时，师生之间的互动也随之改善，我们可以通过具体的实例来从老师那学到更多的实用的知识。 数据结构课程具有比较强的理论性，同时也具有较强的可应用性和实践性。课程设计是一个重要的教学环节。我们在一般情况下都能够重视实验环节，但是容易忽略实验的总结，忽略实验报告的撰写。通过这次实验让我们明白：作为一名大学生必须严格训练分析总结能力、书面表达能力。需要逐步培养书写科学实验报告以及科技论文的能力。只有这样，我们的综合素质才会有好的提高。 实验二二叉树的遍历及霍夫曼编码 班级：计科1101班 学号：0909101605 姓名：杜茂鹏 2013年5月22日 一、实验目的 掌握二叉树的建立及遍历操作，霍夫曼编码基本操作及存储结构表示 二、实验内容 1. 系统要求包含以下功能 1）初始化：从终端读入字符集大小n，以及n个字符和n个权值（或者读入字符集和频度数据文件），建立哈夫曼树，并将哈夫曼树存入到文件HfmTree 中。 2）编码：利用已建好的哈夫曼树（如果不在内存中，则从文件中读入），从文件ToBeTran中读入原文，对原文进行编码，将编码后的结果存入文件CodeFile 中。 3）译码：利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。 4）打印：打印输出哈夫曼树，显示ToBeTran, TextFile和CodeFile文件的内容。 三、实验要求 1．在上机前写出全部源程序； 2．能在机器上正确运行程序； 3．用户界面友好。 四、概要设计 1）首先动态分配数组存储霍夫曼树及存储霍夫曼编码表，然后从终端或文件读入霍夫曼树的字符变量及其频度，初始化建立霍夫曼树并将其写入文件HfmTree.txt中。 2）从指定的文件succe.txt中读入原文，利用已经编好的霍夫曼树对其编码，将编码结果写入文件Coding.txt保存。 3）利用已建好的哈夫曼树将文件Coding.txt中的代码进行译码，结果存入文件decoding.txt中。 五、测试数据： 2．原文内容“THIS IS MY PROGRAM” 六、详细设计 实验内容(原理、操作步骤、程序代码) //建立霍夫曼树，对原文进行编码、译码 #include 哈夫曼编码课程设计报 告 Last revised by LE LE in 2021 湖南科技学院 数据结构课程设计报告课题: 霍夫曼编码 专业班级：信计1202 学号： 姓名：黄思琪 指导教师: 牛志毅 1 课程设计的目的和意义 在当今信息爆炸时代，如何采用有效的数据压缩技术来节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视。哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。 哈夫曼编码的应用很广泛，利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。树中从根到每个叶子都有一条路径，对路径上的各分支约定：指向左子树的分支表示“0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或“1”的序列作为和各个对应的字符的编码，这就是哈夫曼编码。 通常我们把数据压缩的过程称为编码，解压缩的过程称为解码。电报通信是传递文字的二进制码形式的字符串。但在信息传递时，总希望总长度尽可能最短，即采用最短码。 2．需求分析 课题：哈夫曼编码译码器系统 问题描述：打开一篇英文文章，统计该文章中每个字符出现的次数，然后以它们作为权值，对每一个字符进行编码，编码完成后再对其编码进行译码。 问题补充：1. 从硬盘的一个文件里读出一段英语文章； 2. 统计这篇文章中的每个字符出现的次数； 3. 以字符出现字数作为权值，构建哈夫曼树 4. 对每个字符进行编码并将所编码写入文件然后对所编码进行破译。 具体介绍：在本课题中，我们在硬盘D盘中预先建立一个文档，在里面编辑一篇文章(大写)。然后运行程序，调用fileopen()函数读出该文章，显示在界面；再调用tongji()函数对 该文章的字符种类进行统计，并对每个字符的出现次数进行统计，并且在界面上显 示；然后以每个字符出现次数作为权值，调用Create_huffmanTree()函数构建哈夫曼 树。然后调用Huffman_bianma()函数对哈夫曼树进行编码，调用coding()函数将编码 写入文件。 课程论文 题目：哈夫曼树及其应用课程设计报告学号： 201230210115 姓名：黄文宣 班级： 1232101 专业：信息安全 课程名称：数据结构 课程老师：王晓燕 二零一肆年一月 目录 1、课程设计的题目及简介 (3) 2、实验目的 (3) 3、设计说明 (4) 4、总体流图 (4) 5、详细设计 (5) 6、实现部分 (6) 7、测试程序 (9) 8、心得与体会 (10) 一、课程设计题目 哈夫曼树及其应用 数据的读入﹑存储，生成文件，将键盘输入的信息存入指定的文件中；设计一程序求解此问题．哈夫曼（Huffman）编码原理是一种利用二叉树实现的编码原理 建立的哈夫曼树编码，再从键盘输入二进制的编码进行译码，输出译码。 哈夫曼编码的码长是变化的，对于出现频率高的信息，编码的长度较短；而对于出现频率低的信息，编码长度较长。这样，处理全部信息的总码长一定小于实际信息的符号长度。锻炼我们的编码能力，真正理解数据结构的编码思想,并且锻炼我们的动手能力和成员间的配合，提高程序编写能力。 二、实验目的 1 熟悉树的各种存储结构及其特点。 2 掌握建立哈夫曼树和哈夫曼编码的方法及带权路径长度的计算。 三、设计说明 建立哈夫曼树，将哈夫曼树的结构定义为一个结构型的一维数组，每个元素含有四项：权值，双亲，左孩子，右孩子。哈夫曼树上进行二进制编码：往左走，编码为0，往右走，编码为1，然后将从根结点到树叶中的所有0、1排列起来，则得到该树叶的哈夫曼编码。哈夫曼编码用一个结构型的一维数组保存，每个元素包含：编码、编码的开始位置、编码所对应的字符三项。给定的权值从键盘输入，输出所建立的哈夫曼树编码，再从键盘输入二进制的编码进行译码，输出译码。 四、总体流图 哈夫曼树编码系统 初始化 编码 重新建立哈夫 曼树 译码 打印编码 一、需求分析 1、本演示程序实现Haffman编/译码器的作用，目的是为信息收发站提供一个编/译系统， 从而使信息收发站利用Haffman编码进行通讯，力求达到提高信道利用率，缩短时间，降低成本等目标。系统要实现的两个基本功能就是：①对需要传送的数据预先编码； ②对从接收端接收的数据进行译码； 2、本演示程序需要在终端上读入n个字符（字符型）及其权值（整形），用于建立Huffman 树,存储在文件hfmanTree.txt中；如果用户觉得不够清晰还可以打印以凹入表形式显示的Huffman树； 3、本演示程序根据建好的Huffman树，对文件的文本进行编码，结果存入文件CodeFile 中；然后利用建好的Huffman树将文件CodeFile中的代码进行译码，结果存入文件TextFile中；最后在屏幕上显示代码（每行50个），同时显示对CodeFile中代码翻译后的结果； 4、本演示程序将综合使用C++和C语言； 5、测试数据： (1)教材例6-2中数据：8个字符，概率分别是0.05，0.29，0.07，0.08，0.14，0.23，0.03， 0.11，可将其的权值看为5，29，7，8，14，23，3，11 (2)用下表给出的字符集和频度的实际统计数据建立Haffman树，并实现以下报文的编码和 一、概要设计 1、设定哈夫曼树的抽象数据类型定义 ADT Huffmantree{ 数据对象：D={a i| a i∈Charset,i=1,2,3,……n,n≥0} 数据关系：R1＝{< a i-1, a i >| a i-1, a i∈D, i=2,3,……n} 基本操作： Initialization(&HT，&HC,w，n,ch) 操作结果：根据n个字符及其它们的权值w[i],建立Huffman树HT,用字符数组ch[i]作为中间存储变量，最后字符编码存到HC中； Encodeing(n) 操作结果：根据建好的Huffman树，对文件进行编码，编码结果存入到文件CodeFile 中 Decodeing(HT,n) 操作结果：根据已经编译好的包含n个字符的Huffman树HT，将文件的代码进行翻译，结果存入文件TextFile中 } ADT Huffmantree XXX学院本科 数据结构课程设计总结报告 设计题目：实验一、哈夫曼编/译码器 学生姓名：XXX 系别：XXX 专业：XXX 班级：XXX 学号：XXX 指导教师：XXX XXX 2012年6 月21日 xxx学院 课程设计任务书 题目一、赫夫曼编译码器 专业、班级xxx 学号xxx 姓名xxx 主要内容、基本要求、主要参考资料等： 1. 主要内容 利用哈夫曼编码进行信息通信可大大提高信道利用率，缩短信息传输时间，降低传输成本。要求在发送端通过一个编码系统对待传数据预先编码；在接收端将传来的数据进行译码（复原）。对于双工信道（既可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼的编/译码系统。 2. 基本要求 系统应具有以下功能： （1）C：编码（Coding）。对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中，将以此建好的哈夫曼树存入文件HuffmanTree中 （2）D：解码（Decoding）。利用已建好的哈夫曼树将文件codefile中的代码进行译码，结果存入textfile中。 （3）P：打印代码文件（Print）。将文件codefile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件codeprint中。 （4）T：打印哈夫曼树（Tree Printing）。将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件treeprint中。 3. 参考资料：数据结构（C语言版）严蔚敏、吴伟民编着； 数据结构标准教程胡超、闫宝玉编着 完成期限：2012年6月21 日 指导教师签名： 课程负责人签名： 2012年 6月 21 日 一、设计题目（任选其一） 实验一、哈夫曼编/译码器 二、实验目的 1巩固和加深对数据结构的理解，提高综合运用本课程所学知识的能力； 2 深化对算法课程中基本概念、理论和方法的理解； 3 巩固构造赫夫曼树的算法； 4 设计试验用程序实验赫夫曼树的构造。 三、运行环境（软、硬件环境） Windows xp sp3，Visual C++ 英文版 四、算法设计的思想 （1）初始化赫夫曼树，输入文件中各字符及其权值，并保存于文件中 （2）编码（Coding）。对文件tobetrans中的正文进行编码，然后将结果存入文件codefile 中 （3）D：解码（Decoding）。利用已建好的哈夫曼树将文件codefile中的代码进行译码，结果存入textfile中。 （4）P：打印代码文件（Print）。将文件codefile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件codeprint中。 目录 目录 (2) 1课程设计的目的和意义 (3) 2需求分析 (4) 3概要设计 (4) 4详细设计 (8) ￥ 5调试分析和测试结果 (11) 6总结 (12) 7致谢 (13) 8附录 (13) 参考文献 (20) . | ; 1 课程设计目的与意义 在当今信息爆炸时代，如何采用有效的数据压缩技术来节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视。哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。 哈夫曼编码的应用很广泛，利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。树中从根到每个叶子都有一条路径，对路径上的各分支约定：指向左子树的分支表示“0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或“1”的序列作为和各个对应的字符的编码，这就是哈夫曼编码。 通常我们把数据压缩的过程称为编码，解压缩的过程称为解码。电报通信是传递文字的二进制码形式的字符串。但在信息传递时，总希望总长度尽可能最短，即采用最短码。 作为计算机专业的学生，我们应该很好的掌握这门技术。在课堂上，我们能过学到许多的理论知识，但我们很少有过自己动手实践的机会！课程设计就是为解决这个问题提供了一个平台。 （ 在课程设计过程中，我们每个人选择一个课题，认真研究，根据课堂讲授内容，借助书本，自己动手实践。这样不但有助于我们消化课堂所讲解的内容，还可以增强我们的独立思考能力和动手能力；通过编写实验代码和调试运行，我们 可以逐步积累调试C程序的经验并逐渐培养我们的编程能力、用计算机解决实际问题的能力。 在课程设计过程中，我们不但有自己的独立思考，还借助各种参考文献来帮助我们完成系统。更为重要的是，我们同学之间加强了交流，在对问题的认识方面可以交换不同的意见。同时，师生之间的互动也随之改善，我们可以通过具体的实例来从老师那学到更多的实用的知识。 数据结构课程具有比较强的理论性，同时也具有较强的可应用性和实践性。课程设计是一个重要的教学环节。我们在一般情况下都能够重视实验环节，但是容易忽略实验的总结，忽略实验报告的撰写。通过这次实验让我们明白：作为一名大学生必须严格训练分析总结能力、书面表达能力。需要逐步培养书写科学实验报告以及科技论文的能力。只有这样，我们的综合素质才会有好的提高。 2 需求分析 课题：哈夫曼编码译码器 ) 问题描述：打开一篇英文文章，统计该文章中每个字符出现的次数，然后以它们作为权值，对每一个字符进行编码，编码完成后再对其编码进行译码。问题补充：1. 从硬盘的一个文件里读出一段英语文章； 2. 统计这篇文章中的每个字符出现的次数； 3. 以字符出现字数作为权值，构建哈夫曼树，并将哈夫曼树的存储 结构的初态和终态进行输出； 4. 对每个字符进行编码并将所编码写入文件然后对所编码进行破 译。 具体介绍：在本课题中，我们在硬盘中预先建立一个文档，在里面编辑一篇文章。然后运行程序，调用函数读出该文章，显示在界面；再调用函数对该文章的字符种类进行统计，并对每个字符的出现次数进行统计，并且在界面上显示；然后以每个字符出现次数作为权值，调用函数构建哈夫曼树；并调用函数将哈夫曼的存储结构的初态和终态进行输出。然后调用函数对哈夫曼树进行编码，调用函数将编码写入文件；再调用对编码进行译码，再输出至界面。至此，整个工作就完成了 3 概要设计。 中南大学数据结构课程 姓名：刘阳 班级：信息0703 学号：0903070312 实验时间： 08.11.14 指导老师：赵颖 一、实验内容 根据输入的n 个带权结点，构造出哈夫曼树，并且把构造结果输出到屏幕。 二、实验说明 哈夫曼数，也称最优二叉树，是指对于一组带有确定权值的叶结点，构造的具有最小带权路径长度的二叉树。 设二叉树具有n 个带权值的叶结点，那么从根结点到各个叶结点的路径长度与相应结点权值的乘积之和叫做二叉树的带权路径长度WPL ，记作： WPL=k n k k L W *∑=1。在给定一组具有确定权值的叶结点，可以构造出不同的带权二 叉树。根据哈夫曼树的定义，一棵二叉树要使其WPL 值最小，必须使权值越大的叶结点越靠近根结点，而权值越小的叶结点越远离根结点。 在数据通讯中，经常需要将传送的文字转换成由二进制字符0，1组成的二进制串，我们称之为编码。例如，假设要传送的电文为ABACCDA ，电文中只含有A ，B ，C ，D 四种字符，若这四种字符采用下表所示的编码，则电文的代码为000010000100100111 000，长度为21。 在传送电文时，我们总是希望传送时间尽可能短，这就要求电文代码尽可能短。如果在编码时考虑字符出现的频率，让出现频率高的字符采用尽可能短的编码，出现频率低的字符采用稍长的编码，构造一种不等长编码，则电文的代码就可能更短。并且在建立不等长编码时，必须使任何一个字符的编码都不是另一个字符编码的前缀，以避免反译成原文时，编码出现多义性。 在哈夫曼编码树中，树的带权路径长度的含义是各个字符的码长与其出现次数的乘积之和，也就是电文的代码总长，所以采用哈夫曼树构造的编码是一种能使电文代码总长最短的不等长编码。 采用哈夫曼树进行编码，也不会产生上述二义性问题。因为，在哈夫曼树中，每个字符结点都是叶结点，它们不可能在根结点到其它字符结点的路径上，所以一个字符的哈夫曼编码不可能是另一个字符的哈夫曼编码的前缀，从而保证了译码的非二义性。 课程设计 题目：哈夫曼编码器 院系： 专业班级： 学号： 学生姓名： 指导教师： 2014年1月2日 课程设计需求分析报告 一、分析问题和确定解决方案 1.分析问题 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统,为这样的信息收发站写一个哈夫曼的编/译码系统。 2.确定解决方案 设计建立带权的哈夫曼树，确定哈夫曼树的类与成员函数，以及各函数之间的调用关系，采用动态数组的存储结构存储所需要的数据，通过不同的函数来实现编码，译码以及打印二进制编码、哈夫曼树，把不同的数据存入不同的txt文件中，通过主函数调用来实现功能检测。 3.输入的形式和输入值的范围 手动或者从文本中读入数据的形式初始化哈夫曼树，从键盘中或者文件中读入数据，以字母A-Z代表结点，以自然数代表权值，字符串提示使用者所要执行的操作。 4.输出的形式 在显示器界面上或者以文本的形式来实现程序调试的输出。 5.程序所能达到的功能 (1)初始化。手动输入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件WritehfmTree中,输出哈夫曼树及各字符对应的编码存于WritehfmCode;从文本中读入字符，建立哈夫曼树存于ReadhfmTree, 输出哈夫曼树及各字符对应的编码存于ReadhfmCode. (2)编码。手动输入一串大写英文字符，该字符存于WriteToBeTron中，对字符进行编码并将它存于WriteCodeFile中；从文件中读取字符编码并存于ReadCodeFile中。 (3)印代码文件。将文件ReadCodeFile以紧凑格式显示在终端上，每行50个代码。同时将 【关键字】报告 课程设计 题目哈夫曼编码 学院计算机科学与技术 专业计算机科学与技术 班级 姓名 指导教师 2010 年07 月02 日 课程设计任务书 学生姓名：拉巴珠久专业班级：计算机0806 指导教师：姚寒冰工作单位：计算机科学系 题目: 哈夫曼编码 初始条件： 输入一段英文字符，试为该文中的每个字符编制相应的哈夫曼码。 （1）I：初始化（Initialization）。对输入的一段英文中的每个字符统计其权值，建立哈夫曼树； （2）E：编码（Encoding）。利用已建好的哈夫曼树，对每个字符进行编码。 （3）D：译码（Decoding）。利用已建好的每个编码，对输入的一个由0、1组成的序列进行译码； （4）P：印代码文件（Print）。将每个字符编的哈夫曼码和译码结果显示在终端上。 尝试用例见题集p149。 要求完成的主要任务: （包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 课程设计报告按学校规定格式用A4纸打印（书写），并应包含如下内容： 1、问题描述 简述题目要解决的问题是什么。 2、设计 存储结构设计、主要算法设计（用类C语言或用框图描述）、尝试用例设计； 3、调试报告 调试过程中遇到的问题是如何解决的；对设计和编码的讨论和分析。 4、经验和体会（包括对算法改进的设想） 5、附源程序清单和运行结果。源程序要加注释。如果题目规定了尝试数据，则运行结果要包含这些尝试数据和运行输出， 6、设计报告、程序不得相互抄袭和拷贝；若有雷同，则所有雷同者成绩均为0分。 时间安排： 1、第18周（至）完成。 2、日08：30到计算中心检查程序、交课程设计报告、源程序（CD盘）。指导教师签名：年月日 系主任（或责任教师）签名：年月日 哈夫曼树实验报告 Company number：【0089WT-8898YT-W8CCB-BUUT-202108】 计算机科学与技术学院数据结构实验报告 班级 2014级计算机1班学号姓名张建华成绩 实验项目简单哈夫曼编/译码的设计与实现实验日期一、实验目的 本实验的目的是进一步理解哈夫曼树的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。 二、实验问题描述 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码，此实验即设计这样的一个简单编/码系统。系统应该具有如下的几个功能： 1、接收原始数据。 从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件中。 2、编码。 利用已建好的哈夫曼树（如不在内存，则从文件中读入），对文件中的正文进行编码，然后将结果存入文件中。 3、译码。 利用已建好的哈夫曼树将文件中的代码进行译码，结果存入文件中。 4、打印编码规则。 即字符与编码的一一对应关系。 5、打印哈夫曼树， 将已在内存中的哈夫曼树以直观的方式显示在终端上。 三、实验步骤 1、实验问题分析 1、构造哈夫曼树时使用静态链表作为哈夫曼树的存储。 在构造哈夫曼树时，设计一个结构体数组HuffNode保存哈夫曼树中各结点的信息，根据二叉树的性质可知，具有n个叶子结点的哈夫曼树共有2n-1个结点，所以数组HuffNode的大小设置为2n-1，描述结点的数据类型为： Typedef strcut { Int weight；/*结点权值*/ Int parent； Int lchild； Int rchild； }HNodeType； 2、求哈夫曼编码时使用一维结构数组HuffCode作为哈夫曼编码信息的存储。 求哈夫曼编码，实质上就是在已建立的哈夫曼树中，从叶子结点开始，沿结点的双亲链域回退到根结点，没回退一步，就走过了哈夫曼树的一个分支，从而得到一位哈夫曼码值，由于一个字符的哈夫曼编码是从根结点到相应叶子结点所经过的路 一、需求分析 1.运行环境：Microsoft Visual C++ 2.程序所实现的功能： 初始化：输入一串字符（正文），计算不同字符(包括空格)的数目以及每种字符出现的频率(以该种字符出现的次数作为其出现频率），根据权值建 立哈夫曼树，输出每一种字符的哈夫曼编码。 编码：利用求出的哈夫曼编码，对该正文（字符串）进行编码，并输出。 译码：对于得到的一串编码，利用已求得的哈夫曼编码进行译码，将译出的正文输出。 输出哈夫曼树形态：以树的形式输出哈夫曼树。 3.程序的输入，包含输入的数据格式和说明: there are three students(char型) 4.程序的输出，程序输出的形式： ②统计字符出现次数并输出 ③根据字符出现次数求出哈夫曼编码并输出（根据算法差异得到的编码可能不 同，但应具有两个特征，一是编码长度应与表中相同，二是编码应该是前缀编码） ④以树的形式输出哈夫曼树 二、设计说明 1. 算法设计的思想 1) 确定哈夫曼树和哈夫曼编码的储存表示 2)在HT[1..n]中选择parent为0的且weight最小的两个节点s1和 s2 3)w存放n个字符的权值(均>0)，构造哈夫曼树HT，输出静态链表(数组)储存哈夫曼树储存结构模拟，然后求出n个字符的哈夫曼编码HC 4)利用哈夫曼编码对密文进行译码，输出译后的字符串 5) 在main()中实现：输入一串字符（正文），计算不同字符(包括空格)的数目以及每种字符出现的频率(以该种字符出现的次数作为其出现频率,然后调用各子函数实现该程序功能 2.主要的数据结构设计说明 Select(HuffmanTree &HT, int n, int &s1, int &s2) {//在HT[1..n]中选择parent为0且weight最小的两个结点， // 其序号分别为s1和s2。 HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n) { // w存放n个字符的权值(均>0)，构造哈夫曼树HT， // 并求出n个字符的哈夫曼编码HC for (i=n+1; i<=m; i++) { // 建哈夫曼树 // 在HT[1..i-1]中选择parent为0且weight最小的两个结点， // 其序号分别为s1和s2。 Select(HT, i-1, s1, s2); HT[s1].parent = i; HT[s2].parent = i; HT[i].lchild = s1; HT[i].rchild = s2; HT[i].weight = HT[s1].weight + HT[s2].weight; HuffmanTran(HuffmanTree &HT,char* &str1,char* &str2,int n) {//利用哈夫曼编码对密文进行译码，输出译后的字符串 3.程序的主要流程图 数据结构实验报告 ――实验五简单哈夫曼编/译码的设计与实现 本实验的目的是通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结 构在实际问题中的应用。此实验可以作为综合实验，阶段性实验时可以选择其中的几个功能来设计和实现。 一、【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行 译码，此实验即设计这样的一个简单编/码系统。系统应该具有如下的几个功能： 1、接收原始数据。 从终端读入字符集大小n,以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nodedata.dat 中。 2、编码。 利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat中读入），对文件中的正 文进行编码，然后将结果存入文件code.dat中。 3、译码。利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件textfile.dat 中。 4、打印编码规则。 即字符与编码的一一对应关系。 二、【数据结构设计】 1、构造哈夫曼树时使用静态链表作为哈夫曼树的存储。 在构造哈夫曼树时，设计一个结构体数组HuffNode保存哈夫曼树中各结点的信息，根 据二叉树的性质可知，具有n个叶子结点的哈夫曼树共有2n-1个结点，所以数组HuffNode 的大小设置为2n-1，描述结点的数据类型为： typedef struct { int weight;//结点权值 int pare nt; int lchild; int rchild; char inf; }HNodeType; 2、求哈夫曼编码时使用一维结构数组HuffCode作为哈夫曼编码信息的存储。 求哈夫曼编码，实质上就是在已建立的哈夫曼树中，从叶子结点开始，沿结点的双亲链 域回退到根结点，没回退一步，就走过了哈夫曼树的一个分支，从而得到一位哈夫曼码值，由于一个字符的哈夫曼编码是从根结点到相应叶子结点所经过的路径上各分支所组成的0、1序列，因此先得到的分支代码为所求编码的低位码，后得到的分支代码位所求编码的高位码，所以设计如下数据类型： #defi ne MAXBIT 10 typedef struct 计算机学院信管专业 数据结构课程设计 题目：哈夫曼树的应用班级： 姓名：学号： 同组人姓名： 起迄日期： 课程设计地点: 指导教师： 评阅意见： 成绩评定： 评阅人：日期： 完成日期：2012年12月 目录 一、需求分析 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析和测试结果 (7) 五、心得体会和总结 (10) 六、参考文献 (10) 七、附录 (11) 一、需求分析 （一）实验要求 要求用到数据结构课上学到的线性表的知识，所以就要充分而清晰的理解关于线性表的知识。 要求实现的基本功能很简单，只有删除和插入，增加功能也不过是加上修改。这些在数据结构课上已经讲过，只要能够理解关于线性表的几个相关的基本算法就可以了。 问题是将输入的信息保存入文件和从文件输出。这里基本是自学的内容，而且要考虑到是否要自行选择保存的磁盘。 综上，做这个课题，要具备的知识就是线性表的基本算法，文件的保存和读取算法，必要的C或者C++知识（本次我将使用C++实现），以及丰富的程序调适经验。 （二）实验任务 一个完整的系统应具有以下功能： 功能1．从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树并将它存于文件hfmTree中.将已在内存中的哈夫曼树以直观的方式（比如树）显示在终端上； 功能2．利用已经建好的哈夫曼树（如不在内存，则从文件htmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中，并输出结果，将文件CodeFile以紧凑格式先是在终端上，每行50个代码。同时将此字符形式的编码文件写入文件CodePrint中。 功能3．利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中，并输出结果。 （三）实验步骤 分步实施： 1）初步完成总体设计，搭好框架，确定人机对话的界面，确定函数个数； 2）完成最低要求：完成功能1； 3）进一步要求：完成功能2和3。有兴趣的同学可以自己扩充系统功能。要求： 1）界面友好，函数功能要划分好 2）总体设计应画一流程图 3）程序要加必要的注释 4) 要提供程序测试方案 5）程序一定要经得起测试，宁可功能少一些，也要能运行起来，不能运行的程序是没有价值的。 电子科技大学 实验报告 课程名称：数据结构与算法 学生姓名：陈*浩 学号：************* 点名序号： *** 指导教师：钱** 实验地点：基础实验大楼 实验时间： 2014-2015-2学期 信息与软件工程学院 实验报告(二) 学生姓名：陈**浩学号：*************指导教师：钱** 实验地点：科研教学楼A508实验时间：一、实验室名称：软件实验室 二、实验项目名称：数据结构与算法—树 三、实验学时：4 四、实验原理： 霍夫曼编码（Huffman Coding）是一种编码方式，是一种用于无损数据压缩的熵编码（权编码）算法。1952年，David A. Huffman在麻省理工攻读博士时所发明的。 在计算机数据处理中，霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。 例如，在英文中，e的出现机率最高，而z的出现概率则最低。当利用霍夫曼编码对一篇英文进行压缩时，e极有可能用一个比特来表示，而z则可能花去25个比特（不是26）。用普通的表示方法时，每个英文字母均占用一个字节（byte），即8个比特。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。 霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为WPL=(W1*L1+W2*L2+W3*L3+...+Wn*Ln)，N个权值Wi（i=1,2,...n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,...n）。 可以证明霍夫曼树的WPL是最小的。 课程设计 题目哈夫曼编码 学院计算机科学与技术 专业计算机科学与技术 班级 姓名 指导教师 2010 年07 月02 日 课程设计任务书 学生姓名：拉巴珠久专业班级：计算机0806 指导教师：姚寒冰工作单位：计算机科学系 题目: 哈夫曼编码 初始条件： 输入一段英文字符，试为该文中的每个字符编制相应的哈夫曼码。 （1）I：初始化（Initialization）。对输入的一段英文中的每个字符统计其权值，建立哈夫曼树； （2）E：编码（Encoding）。利用已建好的哈夫曼树，对每个字符进行编码。 （3）D：译码（Decoding）。利用已建好的每个编码，对输入的一个由0、1组成的序列进行译码； （4）P：印代码文件（Print）。将每个字符编的哈夫曼码和译码结果显示在终端上。 测试用例见题集p149。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要 求） 课程设计报告按学校规定格式用A4纸打印（书写），并应包含如下内容： 1、问题描述 简述题目要解决的问题是什么。 2、设计 存储结构设计、主要算法设计（用类C语言或用框图描述）、测试用例设计； 3、调试报告 调试过程中遇到的问题是如何解决的；对设计和编码的讨论和分析。 4、经验和体会（包括对算法改进的设想） 5、附源程序清单和运行结果。源程序要加注释。如果题目规定了测试数据，则运行结果要包含这些测试数据和运行输出， 6、设计报告、程序不得相互抄袭和拷贝；若有雷同，则所有雷同者成绩均为0分。 时间安排： 1、第18周（6月28日至7月2日）完成。 2、7月2 日08：30到计算中心检查程序、交课程设计报告、源程序（CD盘）。 指导教师签名：年月日 系主任（或责任教师）签名：年月日 湖南科技学院 数据结构课程设计报告课题: 霍夫曼编码 专业班级：信计1202 学号：201205001239 姓名：黄思琪 指导教师: 牛志毅 1 课程设计的目的和意义 在当今信息爆炸时代，如何采用有效的数据压缩技术来节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视。哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。 哈夫曼编码的应用很广泛，利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。树中从根到每个叶子都有一条路径，对路径上的各分支约定：指向左子树的分支表示“0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或“1”的序列作为和各个对应的字符的编码，这就是哈夫曼编码。 通常我们把数据压缩的过程称为编码，解压缩的过程称为解码。电报通信是传递文字的二进制码形式的字符串。但在信息传递时，总希望总长度尽可能最短，即采用最短码。 2．需求分析 课题：哈夫曼编码译码器系统 问题描述：打开一篇英文文章，统计该文章中每个字符出现的次数，然后以它们作为权值，对每一个字符进行编码，编码完成后再对其编码进行译码。问题补充：1. 从硬盘的一个文件里读出一段英语文章； 2. 统计这篇文章中的每个字符出现的次数； 3. 以字符出现字数作为权值，构建哈夫曼树 4. 对每个字符进行编码并将所编码写入文件然后对所编码进行破 译。 具体介绍：在本课题中，我们在硬盘D盘中预先建立一个xuzhimo.txt文档，在里面编辑一篇文章(大写)。然后运行程序，调用fileopen()函数读出该 文章，显示在界面；再调用tongji()函数对该文章的字符种类进行统计， 并对每个字符的出现次数进行统计，并且在界面上显示；然后以每个 字符出现次数作为权值，调用Create_huffmanTree()函数构建哈夫曼 树。然后调用Huffman_bianma()函数对哈夫曼树进行编码，调用 coding()函数将编码写入文件。哈夫曼编码译码系统实验报告,数据结构课程设计报告
哈夫曼(huffman)编译码器课程设计
数据结构哈夫曼编码译码器课程设计报告(有源程序)
霍夫曼树实验报告
哈夫曼编码课程设计报告
哈夫曼树课程设计论文
哈夫曼树的实验报告1
哈夫曼编译码器课程设计报告完整版
哈夫曼编码译码器---课程设计报告
哈夫曼编码实验报告
哈夫曼树课程设计报告(DOC)
【报告】课程设计报告哈夫曼编码
哈夫曼树实验报告
哈夫曼编译码课程设计报告
数据结构哈夫曼编码实验报告
数据结构课程设计实验报告哈夫曼树的应用
哈夫曼树及其操作-数据结构实验报告(2)
课程设计报告哈夫曼编码
哈夫曼编码课程设计报告
相关主题
文本预览