哈夫曼压缩解压算法源码.docx
《哈夫曼压缩解压算法源码.docx》由会员分享，可在线阅读，更多相关《哈夫曼压缩解压算法源码.docx（12页珍藏版）》请在冰豆网上搜索。
哈夫曼压缩解压算法源码
哈夫曼压缩解压算法源码
HUFFMAN.C
#include
#include
#include
main（argc,argv）
intargc;
char*argv[];
{
intf,er;
intlen,arc;
char*inbuff;
char*outbuff;
charfname[80];
charch;
if（argc<2）{
puts（"Getmeparams!
"）;
exit
（1）;
}
strcpy（fname,argv[1]）;
f=_open（fname,O_RDONLY）;
if（f<0）{
puts（"Openerror"）;
exit
（1）;
}
len=（int）filelength（f）;
if（len<0）{
puts（"Filetoolarge"）;
exit
（1）;
}
inbuff=malloc（len）;
if（inbuff==NULL）{
puts（"Notenoughmemory"）;
exit
（1）;
}
len=_read（f,inbuff,len）;
if（len<0）{
puts（"Readerror"）;
exit
（1）;
}
_close（f）;
if（!
ntIsarc（inbuff+1））{
outbuff=malloc（len）;
if（outbuff==NULL）{
puts（"Notenoughmemory"）;
exit
（1）;
}
printf（"Packing%sto",fname）;
ch=*fname;
*fname='$';
printf（"%s...",fname）;
arc=ntEncode（outbuff,inbuff,len）;
if（arc==0）{
puts（"Encodefailure"）;
exit
（1）;
}
f=_creat（fname,FA_ARCH）;
if（f<0）{
puts（"Createerror"）;
exit
（1）;
}
er=_write（f,&ch,1）;
er=_write（f,outbuff,arc）;
if（er<0）{
puts（"Writeerror"）;
exit
（1）;
}
_close（f）;
printf（"Success.%.2f%%\n",（（float）（len-arc）/（float）len）*100.0）;
}
else{
len=ntGetorig（inbuff+1）;
outbuff=malloc（len）;
if（outbuff==NULL）{
puts（"Notenoughmemory"）;
exit
（1）;
}
printf（"Unpacking%sto",fname）;
*fname=*inbuff;
printf（"%s...",fname）;
arc=ntDecode（outbuff,inbuff+1）;
if（arc==0）{
puts（"Decodefailure"）;
exit
（1）;
}
f=_creat（fname,FA_ARCH）;
if（f<0）{
puts（"Createerror"）;
exit
（1）;
}
er=_write（f,outbuff,len）;
if（er<0）{
puts（"Writeerror"）;
exit
（1）;
}
_close（f）;
puts（"Success."）;
}
}
NTDECODE.C
#defineUS037
#defineRS036
char*_inp;
char*_outp;
int_origsize;
short_dmaxlev;
short_intnodes[25];char*_tree[25];
char_characters[256];char*_eof;
intntDecode（outbuff,inbuff）
char*outbuff;
char*inbuff;
{
intc,i,nchildren;
intinleft;
_eof=&_characters[0];
if（inbuff[0]!
=US）return（0）;
if（inbuff[1]!
=RS）return（0）;
_inp=&inbuff[2];
_origsize=0;
for（i=0;i<4;i++）
_origsize=_origsize*256+（（*_inp++）&0377）;
inleft=_origsize;
_dmaxlev=*_inp++&0377;
if（_dmaxlev>24）return（0）;
for（i=1;i<=_dmaxlev;i++）
_intnodes[i]=*_inp++&0377;
for（i=1;i<=_dmaxlev;i++）{
_tree[i]=_eof;
for（c=_intnodes[i];c>0;c--）{
if（_eof>=&_characters[255]）return（0）;
*_eof++=*_inp++;
}
}
*_eof++=*_inp++;
_intnodes[_dmaxlev]+=2;
inleft-=_inp-&inbuff[0];
if（inleft<0）return（0）;
nchildren=0;
for（i=_dmaxlev;i>=1;i--）{
c=_intnodes[i];
_intnodes[i]=nchildren/=2;
nchildren+=c;
}
return（_decode（inleft,outbuff））;}
_decode（inleft,outbuff）
intinleft;
char*outbuff;
{
intbitsleft,c,i;
intj,lev;
char*p;
_outp=&outbuff[0];
lev=1;
i=0;
while
（1）{
if（--inleft<0）return（0）;
c=*_inp++;
bitsleft=8;
while（--bitsleft>=0）{
i*=2;
if（c&0200）
i++;
c<<=1;
if（（j=i-_intnodes[lev]）>=0）{
p=&_tree[lev][j];
if（p==_eof）{
c=_outp-&outbuff[0];
_origsize-=c;
if（_origsize!
=0）return（0）;
return
（1）;
}
*_outp++=*p;
lev=1;
i=0;
}else
lev++;
}
}
}
NTENCODE.C
#defineEND256
unionFOUR{
struct{longlng;}lint;
struct{charc0,c1,c2,c3;}chars;
};
long_count[END+1];unionFOUR_insize;
int_diffbytes;
int_maxlev;
int_levcount[25];int_lastnode;
int_parent[2*END+1];
char_length[END+1];long_bits[END+1];unionFOUR_mask;
long_inc;
char*_maskshuff[4]={&（_mask.chars.c3）,&（_mask.chars.c2）,
&（_mask.chars.c1）,&（_mask.chars.c0）};
int_n_;
struct_heap{
longcount;
intnode;
}_heap[END+2];
#definehmove（a,b）{（b）.count=（a）.count;（b）.node=（a）.node;}
intntEncode（outbuff,inbuff,buflen）char*outbuff;
char*inbuff;
intbuflen;
{
registerintc,i,p;
longbitsout;
_input（inbuff,buflen）;
_diffbytes=-1;
_count[END]=1;
_insize.lint.lng=0L;
_n_=0;
for（i=END;i>=0;i--）{
_parent[i]=0;
if（_count[i]>0）{
_diffbytes++;
_insize.lint.lng+=_count[i];
_heap[++_n_].count=_count[i];
_heap[_n_].node=i;
}
}
if（_diffbytes==1）return（0）;
_insize.lint.lng>>=1;
for（i=_n_/2;i>=1;i--）
_heapify（i）;
_lastnode=END;
while（_n_>1）{
_parent[_heap[1].node]=++_lastnode;
_inc=_heap[1].count;
hmove（_heap[_n_],_heap[1]）;
_n_--;
_heapify
（1）;
_parent[_heap[1].node]=_lastnode;
_heap[1].node=_lastnode;
_heap[1].count+=_inc;
_heapify
（1）;
}
_parent[_lastnode]=0;
bitsout=_maxlev=0;
for（i=1;i<=24;i++）
_levcount[i]=0;
for（i=0;i<=END;i++）{
c=0;
for（p=_parent[i];p!
=0;p=_parent[p]）
c++;
_levcount[c]++;
_length[i]=c;
if（c>_maxlev）
_maxlev=c;
bitsout+=c*（_count[i]>>1）;
}
if（_maxlev>24）return（0）;
_inc=1L<<24;
_inc>>=_maxlev;
_mask.lint.lng=0;
for（i=_maxlev;i>0;i--）{
for（c=0;c<=END;c++）
if（_length[c]==i）{
_bits[c]=_mask.lint.lng;
_mask.lint.lng+=_inc;
}
_mask.lint.lng&=~_inc;
_inc<<=1;
}
return（_output（outbuff,inbuff,buflen））;}
_input（inbuff,buflen）
char*inbuff;
intbuflen;
{
registerinti;
for（i=0;i_count[i]=0;
while（buflen>0）
_count[inbuff[--buflen]&0377]+=2;}
int_output（outbuff,inbuff,buflen）char*outbuff;
char*inbuff;
intbuflen;
{
intc,i;
char*inp;
registerchar**q,*outp;
registerintbitsleft;
longtemp;
outbuff[0]=037;/*asciiUS*/
outbuff[1]=036;/*asciiRS*/
temp=_insize.lint.lng;
for（i=5;i>=2;i--）{
outbuff[i]=（char）（temp&0377）;
temp>>=8;
}
outp=outbuff+6;
*outp++=_maxlev;
for（i=1;i<_maxlev;i++）
*outp++=_levcount[i];
*outp++=_levcount[_maxlev]-2;
for（i=1;i<=_maxlev;i++）
for（c=0;cif（_length[c]==i）
*outp++=c;
inp=inbuff;
bitsleft=8;
do{
c=（--buflen<0）?
END:
（*inp++&0377）;
_mask.lint.lng=_bits[c]<q=&_maskshuff[0];
if（bitsleft==8）
*outp=**q++;
else
*outp|=**q++;
bitsleft-=_length[c];
while（bitsleft<0）{
*++outp=**q++;
bitsleft+=8;
}
}while（c!
=END）;
if（bitsleft<8）
outp++;
c=outp-outbuff;
return（c）;
}
_heapify（i）
inti;
{
registerintk;
intlastparent;
struct_heapheapsubi;
hmove（_heap[i],heapsubi）;
lastparent=_n_/2;
while（i<=lastparent）{
k=2*i;
if（_heap[k].count>_heap[k+1].count&&k<_n_）
k++;
if（heapsubi.count<_heap[k].count）
break;
hmove（_heap[k],_heap[i]）;
i=k;
}
hmove（heapsubi,_heap[i]）;}
NTGETORI.C
intntGetorig（inbuff）char*inbuff;
{
inti;
char*in;
intsize;
in=inbuff+2;
size=0;
for（i=0;i<4;i++）
size=size*256+（（*in++）&0377）;
return（size）;
}
NTISARC.C
#defineUS037
#defineRS036
intntIsarc（inbuff）char*inbuff;
{
if（inbuff[0]==US&&inbuff[1]==RS）
return
（1）;
else
return（0）;
}
升级会员 