哈夫曼树的编码与解码

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
typedef struct{
char node;
int weight;
int parent,lchild,rchild;
//找到哈夫曼树的根节点
i=0;
while(HT[i].parent!=-1) {
i=HT[i].parent;}
root=i;
//对应编码依次比较，从根节点开始直到叶子节点，找出对应的编码
*yima=(char*)malloc(100000000*sizeof(char));
//取HT[0..n]中的权值最小值的下标S1和次小值的下标S2
int i;
int min1=99999999,min2=99999999;
for(i=0;i<=n;i++){
if(HT[i].parent!=-1) continue;
else if(HT[i].weight<min1){
//构造哈夫曼树HT，并求出N个字符的哈夫曼编码HC
int i,m,j=0,s1=-1,s2=-1;
if(n<=1) return;
m=2*n-1;
HT=(HuffmanTree)malloc(m*sizeof(HTNode));
for(i=-256;i<256;i++){
if(HC[i+256].weight!=0){
for(j=6;j>=0;j--){
a=pow(2,j);
if(p[i]>=a) {
c[7*i+6-j]='1';
p[i]-=a;
}
else c[7*i+6-j]='0';
}
}
if(n!=0) c[m*7+n-7]='\0';
else c[m*7]='\0';
min2=min1;
*s2=*s1;
min1=HT[i].weight;
*s1=i;
}
else if(HT[i].weight<min2){
min2=HT[i].weight;
*s2=i;
}
}
}
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int n){
if(q[7*i+j]=='1') num+=pow(2,6-j);
}
if(num==26)
c[i]=-3;
else if(num==0)
c[i]=-4;
else
c[i]=num;
}
c[i]='\0';
}
void DEC_TO_BIN(char *p,char *&c,int n){
fp=fopen(filename,"w");
fwrite(bianma,1,strlen(bianma),fp);
fclose(fp);
printf("保存完毕\n");
}
int main(){
int n,i,s;
char *input;
int nn;
char *c;
BIN_TO_DEC((char*)bianma,c,nn);
Filesoutput(c);
float bb;
bb=(float)(strlen(bianma))/((float)(strlen(input))*8);
printf("\n压缩比为%f\n",bb);
HT[j].node=HC[i+256].node;
HT[j].weight=HC[i+256].weight;
HT[j].parent=HT[j].lchild=HT[j].rchild=-1;
j++;
}
}
for(;j<m;j++){
HT[j].node='\0';
j=l=0,k=root;
while(bianma[j]!=0){
while(HT[k].lchild!=-1&&HT[k].rchild!=-1){
if(bianma[j]=='0') {k=HT[k].lchild;j++;}
else if(bianma[j]=='1') {k=HT[k].rchild;j++;}
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树
typedef struct{
char node;
int weight;
char *code;
}Code,*HuffmanCode;//动态分配数组存储哈夫曼编码表
void ChooseMin(HuffmanTree HT,int n,int *s1,int *s2){
}
len+=strlen(HC[input[i]+256].code);
(*bianma)[len]=0;
i++;
}
}
void Yima(char *bianma,char **yima,HuffmanTree HT){
int i,j,k,l,root;
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;
}
//从叶子到根逆向求每个字符的哈夫曼编码
char *cd;
HC[i+256].weight=0;
HC[i+256].code=NULL;
}
Weight(input,HC,n);
HuffmanTree HT;
fmanCoding(HT,HC,n);
char *bianma,*yima;
Bianma(HC,&bianma,input);
if(HT[f].lchild==c) cd[--start]='0';
else cd[--start]='1';
}
k=n-start;
j=HT[i].node;
HC[j+256].code=(char*)malloc(k*sizeof(char));
strcpy(HC[j+256].code,&cd[start]);
int k;
cd=(char*)malloc(n*sizeof(char));
int start,c,f;
cd[n-1]='\0';
for(i=0;i<n;i++){
start=n-1;
for(c=i,f=HT[i].parent;f!=-1;c=f,f=HT[f].parent){
}
(*yima)[l]=HT[k].node;
l++;
k=root;
}
(*yima)[l]=0;
}
void BIN_TO_DEC(char *p,char *&c,int &n){
//将以字符串形式表示的二进制码每七位一截转换成十进制
//并以字符型数据存储，最后不足七位的在末尾补零
//以下为解压操作
printf("\n解压文件：");
char *p;
Filesinput(&p);
DEC_TO_BIN(p,bianma,nn);
Yima(bianma,&yima,HT);
Filesoutput(yima);
getchar();
i++;
}
for(;j<512;j++){
if(HC[j].weight!=0) n++;
}
}
void Bianma(HuffmanCode HC,char **bianma,char *input){
//根据编码表对输入的字符串进行编码
int i=0,j,len=0;
*bianma=(char*)malloc(100000000*sizeof(char));
(*bianma)[0]=0;
while(input[i]){
for(j=0;j<strlen(HC[input[i]+256].code);j++){
(*bianma)[len+j]=HC[input[i]+256].code[j];
}
}
void Weight(char *input,HuffmanCode &HC,int &n){
//对输入的字符串进行处理，求出一共有多少种字符及每个字符的权值