huffman编码

#include <iostream.h> 
#include <iomanip.h> 
#include <string.h> 
#include <malloc.h> 
#include <stdio.h> 


//typedef int TElemType; 
const int UINT_MAX=1000; 
char str[50]; 


typedef struct 
{ 
int weight; 
int parent,lchild,rchild; 
}HTNode,* HuffmanTree; 


typedef char **HuffmanCode; 


//-----------全局变量----------------------- 
HuffmanTree HT; 
HuffmanCode HC; 
int w[50],i,j,n; 
char z[50]; 
int flag=0; 
int numb=0; 


// -----------------求赫夫曼编码----------------------- 
struct cou{ 
char data; 
int count; 
}cou[50]; 


int min(HuffmanTree t,int i) 
{ // 函数void select()调用 
int j,flag; 
int k=UINT_MAX; // 取k为不小于可能的值,即k为最大的权值1000 
for(j=1;j<=i;j++) 
if(t[j].weight<k&&t[j].parent==0) 
k=t[j].weight,flag=j; 
t[flag].parent=1; 
return flag; 
} 


//--------------------slect函数---------------------- 
void select(HuffmanTree t,int i,int &s1,int &s2) 
{ // s1为最小的两个值中序号小的那个 
int j; 
s1=min(t,i); 
s2=min(t,i); 
if(s1>s2) 
{ 
j=s1; 
s1=s2; 
s2=j; 
} 
} 
// --------------算法6.12-------------------------- 
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n) 
{ // w存放n个字符的权值(均>0),构造赫夫曼树HT,并求出n个字符的赫夫曼编码HC 
int m,i,s1,s2,start; 
//unsigned c,f; 
int c,f; 
HuffmanTree p; 
char *cd; 
if(n<=1) 
return;//检测结点数是否可以构成树 
m=2*n-1; 
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用 
for(p=HT+1,i=1;i<=n;++i,++p,++w) 
{ 
p->weight=*w; 
p->parent=0; 
p->lchild=0; 
p->rchild=0; 
} 
for(;i<=m;++i,++p) 
p->parent=0; 
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=HT[s2].parent=i; 
HT[i].lchild=s1; 
HT[i].rchild=s2; 
HT[i].weight=HT[s1].weight+HT[s2].weight; 
} 
// 从叶子到根逆向求每个字符的赫夫曼编码 
HC=(HuffmanCode)malloc((n+1)*sizeof(char*)); 
// 分配n个字符编码的头指针向量([0]不用) 
cd=(char*)malloc(n*sizeof(char)); // 分配求编码的工作空间 
cd[n-1]='\0'; // 编码结束符 
for(i=1;i<=n;i++) 
{ // 逐个字符求赫夫曼编码 
start=n-1; // 编码结束符位置 
for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent) 
// 从叶子到根逆向求编码 
if(HT[f].lchild==c) 
cd[--start]='0'; 
else 
cd[--start]='1'; 
HC[i]=(char*)malloc((n-start)*sizeof(char)); 
// 为第i个字符编码分配空间 
strcpy(HC[i],&cd[start]); // 从cd复制编码(串)到HC 
} 
free(cd); // 释放工作空间 
} 
//---------------------获取报文并写入文件--------------------------------- 
int InputCode() 
{ 
//cout<<"请输入你想要编码的字符"<<endl; 
FILE *tobetran; 


if((tobetran=fopen("tobetran.txt","w"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
return 0; 
} 
cout<<"请输入你想要编码的字符"<<endl; 
gets(str); 
fputs(str,tobetran); 
cout<<"获取报文成功"<<endl; 
fclose(tobetran); 
return strlen(str); 
} 






//--------------初始化赫夫曼链表--------------------------------- 
void Initialization() 
{ int a,k,flag,len; 
a=0; 
len=InputCode(); 
for(i=0;i<len;i++) 
{k=0;flag=1; 
cou[i-a].data=str[i]; 
cou[i-a].count=1; 
while(i>k) 
{ 
if(str[i]==str[k]) 
{ 
a++; 
flag=0; 
} 
k++; 
if(flag==0) 
break; 


} 


if(flag) 
{ 
for(j=i+1;j<len;j++) 
{if(str[i]==str[j]) 
++cou[i-a].count;} 
} 


} 
n=len-a; 
for(i=0;i<n;i++) 
{ cout<<cou[i].data<<" "; //输出统计结果
cout<<cou[i].count<<endl; 
} 
for(i=0;i<=n;i++) 
{*(z+i)=cou[i].data; 
*(w+i)=cou[i].count; 
} 


HuffmanCoding(HT,HC,w,n); 
//------------------------打印编码------------------------------------------- 
cout<<"字符对应的编码为:"<<endl; 
for(i=1;i<=n;i++) 
{ 
puts(HC[i]); 
} 
//--------------------------将赫夫曼编码写入文件------------------------ 
cout<<"下面将赫夫曼编码写入文件"<<endl<<"...................."<<endl; 
FILE *htmTree; 
char r[]={' ','\0'}; 
if((htmTree=fopen("htmTree.txt","w"))==NULL) 
{ 
cout<<"can not open file"<<endl; 
return; 
} 


fputs(z,htmTree); 
for(i=0;i<n+1;i++) 
{ 
fprintf(htmTree,"%6d",*(w+i)); 
fputs(r,htmTree); 
} 
for(i=1;i<=n;i++) 
{ 
fputs(HC[i],htmTree); 
fputs(r,htmTree); 
} 
fclose(htmTree); 
cout<<"已将字符与对应编码写入根目录下文件htmTree.txt中"<<endl<<endl; 
} 
//---------------------编码函数--------------------------------- 
void Encoding() 
{ 
cout<<"下面对目录下文件tobetran.txt中的字符进行编码"<<endl; 


FILE *tobetran,*codefile; 


if((tobetran=fopen("tobetran.txt","rb"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
} 
if((codefile=fopen("codefile.txt","wb"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
} 
char *tran; 
i=99; 
tran=(char*)malloc(100*sizeof(char)); 
while(i==99) 
{ 
if(fgets(tran,100,tobetran)==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
break; 
} 
for(i=0;*(tran+i)!='\0';i++) 
{ 
for(j=0;j<=n;j++) 
{ 
if(*(z+j-1)==*(tran+i)) 
{ 
fputs(HC[j],codefile); 
if(j>n) 
{ 
cout<<"字符错误，无法编码!"<<endl; 
break; 
} 
} 
} 
} 
} 
cout<<"编码工作完成"<<endl<<"编码写入目录下的codefile.txt中"<<endl<<endl; 
fclose(tobetran); 
fclose(codefile); 
free(tran); 
} 
//-----------------译码函数--------------------------------- 
void Decoding() 
{ 
cout<<"下面对根目录下文件codefile.txt中的字符进行译码"<<endl; 
FILE *codef,*txtfile; 
if((txtfile=fopen("txtfile.txt","w"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
} 
if ((codef=fopen("codefile.txt","r"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
} 
char *work,*work2,i2; 
int i4=0,i,i3; 
unsigned long length=10000; 
work=(char*)malloc(length*sizeof(char)); 
fgets(work,length,codef); 
work2=(char*)malloc(length*sizeof(char)); 
i3=2*n-1; 
for(i=0;*(work+i-1)!='\0';i++) 
{ 
i2=*(work+i); 
if(HT[i3].lchild==0) 
{ 
*(work2+i4)=*(z+i3-1); 
i4++; 
i3=2*n-1; 
i--; 
} 
else if(i2=='0') i3=HT[i3].lchild; 
else if(i2=='1') i3=HT[i3].rchild; 
} 
*(work2+i4)='\0'; 
fputs(work2,txtfile); 
cout<<"译码完成"<<endl<<"内容写入根目录下的文件txtfile.txt中"<<endl<<endl; 
free(work); 
free(work2); 
fclose(txtfile); 
fclose(codef); 
} 
//-----------------------打印编码的函数---------------------- 
void Code_printing() 
{ 
cout<<"下面打印根目录下文件CodePrin.txt中编码字符"<<endl; 
FILE * CodePrin,* codefile; 
if((CodePrin=fopen("CodePrin.txt","w"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
return; 
} 
if((codefile=fopen("codefile.txt","r"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
return; 
} 




char *work3; 
work3=(char*)malloc(51*sizeof(char)); 
do 
{ 
if(fgets(work3,51,codefile)==NULL) 
{ 
cout<<"不能读取文件"<<endl; 
break; 
} 
fputs(work3,CodePrin); 
puts(work3); 
}while(strlen(work3)==50); 
free(work3); 
cout<<"打印工作结束"<<endl<<endl; 
fclose(CodePrin); 
fclose(codefile); 
} 
//-------------------------------打印译码函数--------------------------------------------- 
void Code_printing1() 
{ 
cout<<"下面打印根目录下文件txtfile.txt中译码字符"<<endl; 
FILE * CodePrin1,* txtfile; 
if((CodePrin1=fopen("CodePrin1.txt","w"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
return; 
} 
if((txtfile=fopen("txtfile.txt","r"))==NULL) 
{ 
cout<<"不能打开文件"<<endl; 
return; 
} 
char *work5; 
work5=(char*)malloc(51*sizeof(char)); 
do 
{ 
if(fgets(work5,51,txtfile)==NULL) 
{ 
cout<<"不能读取文件"<<endl; 
break; 
} 
fputs(work5,CodePrin1); 
puts(work5); 
}while(strlen(work5)==50); 
free(work5); 
cout<<"打印工作结束"<<endl<<endl; 
fclose(CodePrin1); 
fclose(txtfile); 
} 
//------------------------打印赫夫曼树的函数----------------------- 
void coprint(HuffmanTree start,HuffmanTree HT) 
{ 
if(start!=HT) 
{ 
FILE * TreePrint; 


if((TreePrint=fopen("TreePrint.txt","a"))==NULL) 
{cout<<"创建文件失败"<<endl; 
return; 
} 
numb++;//该变量为已被声明为全局变量 
coprint(HT+start->rchild,HT); 
cout<<setw(5*numb)<<start->weight<<endl; 


fprintf(TreePrint,"%d\n",start->weight); 
coprint(HT+start->lchild,HT); 
numb--; 
fclose(TreePrint); 
} 
} 
void Tree_printing(HuffmanTree HT,int w) 
{ 
HuffmanTree p; 
p=HT+w; 
cout<<"下面打印赫夫曼树"<<endl; 
coprint(p,HT); 
cout<<"打印工作结束"<<endl; 
} 
//------------------------主函数------------------------------------ 
void main() 
{ 
char choice; 
while(choice!='q') 
{ cout<<"\n******************************"<<endl; 
cout<<" 欢迎使用赫夫曼编码解码系统"<<endl; 
cout<<"******************************"<<endl; 
cout<<"(1)要初始化赫夫曼链表请输入'i'"<<endl; 
cout<<"(2)要编码请输入'e'"<<endl; 
cout<<"(3)要译码请输入'd'"<<endl; 
cout<<"(4)要打印编码请输入'p'"<<endl; 
cout<<"(5)要打印赫夫曼树请输入't'"<<endl; 
cout<<"(6)要打印译码请输入'y'"<<endl; 
if(flag==0)cout<<"\n请先初始化赫夫曼链表,输入'i'"<<endl; 
cin>>choice; 
switch(choice) 
{ 
case 'i': 
Initialization(); 
break; 
case 'e': 
Encoding(); 
break; 
case 'd': 
Decoding(); 
break; 
case 'p': 
Code_printing(); 
break; 
case 't': 
Tree_printing(HT,2*n-1); 
break; 
case 'y': 
Code_printing1(); 
break; 
default: 
cout<<"input error"<<endl; 
} 


} 
free(z); 
free(w); 
free(HT); 
}