Java认证:使用哈弗曼编码实现压缩软件

会计考友

Java认证:使用哈弗曼编码实现压缩软件
) d8 }0 [! W7 ^& l2 P使用哈弗曼编码实现压缩软件
1 U/ W) w* Q" E- X( q1.什么是哈夫曼树？
) K# k1 t6 a0 ^) W: O: Y哈夫曼树是一种最优二叉树，它的最优点体现在它的的带权路径长度最小。（结点的带权路径长度为：结点的路径长度乘以结点的权值，树的带权路径长度为所有叶子结点带权路径长度之和）
2.什么是哈弗曼编码？
6 b4 A5 m+ j8 J7 J从哈弗曼树的根结点开始，按照左子树分配代码“0”，右子树分配代码“1”的规则，直到叶子结点为止，每个叶子结点的哈弗曼编码就是从根结点开始，一直到该叶子结点为止，把途中经过的代码按顺序串起来就OK了。
1 X8 ^' x4 p/ N. T7 _" r3.什么是哈弗曼压缩？
% H. V# Q5 X8 @+ nHuffman（ 哈夫曼 ） 算法在上世纪五十年代初提出来了，它是一种无损压缩方法，在压缩过程中不会丢失信息熵，而且可以证明 Huffman 算法在无损压缩算法中是最优的。 Huffman 原理简单，实现起来也不困难，在现在的主流压缩软件得到了广泛的应用。对应用程序、重要资料等绝对不允许信息丢失的压缩场合， Huffman 算法是非常好的选择。
$ c' ~2 ?# U  q" ~哈夫曼压缩，一般用来压缩文本和程序文件。哈夫曼压缩属于可变代码长度算法一族。意思是个体符号（例如，文本文件中的字符）用一个特定长度的位序列替代。因此，在文件中出现频率高的符号，使用短的位序列，而那些很少出现的符号，则用较长的位序列。
有了以上的基本概念，我们就可以动手实现哈弗曼压缩软件了！
& o# |# S4 ?' w; _4.哈弗曼压缩软件的实现：
在文件中，所有的数据都是以字节的形式存在的，一个字节是8位，所以所有可能出现的字节在0——256之间（不包括256），所以，第一步要做的事情就是，把文件所有的字节的出现频率统计出来，并用频率做为权值生成一棵哈弗曼树：
Java代码
# b, G. _+ t# W" Yint［］ ByteCount = new int［256］;//字节频率统计
9 ^4 f0 e; s' R5 ?InputStream fis = new FileInputStream（pathName_former）;
! H+ I! l2 N. YInputStream bis = new BufferedInputStream（fis）;//创建文件输入流
6 ~+ u# R' ^* U, c: D- Ewhile（bis.available（）》0）{
- N9 C6 @7 ^0 v) @* m) k, ^int tmp = bis.read（）;
. _  x# Y6 E: S' @  ?/ ~- vByteCount［tmp］++;
}//统计频率
) u; H; {8 g- x0 U//构造哈弗曼树
) H) B' I) _0 y# d/ J5 W4 g2 \hfmTree hfm = new hfmTree（ByteCount）;
  x9 a8 j+ T4 n1 d# ~1 K9 }Java代码
# Q6 W# y- X: {: ?7 j+ Kpublic hfmTree（int［］ rank）{//根据频率构造哈弗曼树
//把频率不为零的字节加入节点优先级队列
PriorityQueue nodes = new java.util.PriorityQueue（）;
" B, w, S; T( L6 R- O8 t0 Xfor（int i=0;i
if（rank［i］！=0）{
1 ]$ c2 ]' d/ M! K8 V$ Inodes.add（new hfmNode（rank［i］，i））;
}
}
//构造哈弗曼树
8 F9 r+ p% l) Twhile（nodes.size（）！=1）{
hfmNode node_1 = nodes.poll（）;//1
$ S% F6 B9 N: m% U4 {* @3 `) @hfmNode node_2 = nodes.poll（）;//2
. G; c2 H& f. y  Y4 S* \5 ^& HhfmNode addNode = new hfmNode（node_1.getRank（）+node_2.getRank（），0）;
addNode.setLeft（node_1）;
1 G2 k0 N! f, |) J# d, J( BaddNode.setRight（node_2）;
) W- D3 I1 X7 h% \; y  Cnodes.add（addNode）;
}
0 X; o; E# h+ I& J+ r- x* K4 C

8 G; |# u" |) A4 ^. n5 ?root = nodes.poll（）;
}//构造函数（correct）
接下来，要做的就是获得0——256之间每个字节所对应的哈弗曼编码，用一个String［］ Code = new Code［256］保存 下来Java代码//获得编码
private void getStrByte（hfmNode node，String s）{
if（node.getLeft（）==null&&node.getRight（）==null）{
Code［node.getData（）］ = s;//获得编码字符串
}
if（node.getLeft（）！=null）{
0 E5 Z+ q5 Z+ z& [* g$ IgetStrByte（node.getLeft（），s+“0”）;
}//左零 if（node.getRight（）！=null）{
getStrByte（node.getRight（），s+“1”）;
}//右1
}
然后就是把每个字节的编码长度打入文件：Java代码//先将0-255的编码长度打到文件里
for（int i=0;i
' ~# K  d3 ~8 j' b7 H2 n! B% s0 vif（Code［i］==null||Code［i］==“”）{
Code［i］ = “”;
bos.write（0）;
& S+ T4 V, y) H8 |/ U5 U/ N) r}else{
: M# p  E5 i; X0 l% D5 I  dbos.write（Code［i］.length（））;
}
* p) |. E; o( Y; w}
接下来就是，将每个字节的编码打入文件（这里需要吧8个长度的01串转换成一个byte打入文件）：Java代码//把每个字节的编码表打到文件里
int i = 0;//第i个字节
) p2 o7 A# A5 i* e  dint count = 0;//满8打一，计数器
% A- }& z; f5 K  I$ X; H0 jString writeCode = “”;//写入的8位编码
String allCode = “”;//所有待写入的编码
String inCode = “”;
  x6 F0 R1 e5 B5 E$ Xwhile（i《256||count》=8）{
if（count》=8）{//满8
  {- I- }4 l8 t4 a& k2 PwriteCode = allCode.substring（0，8）;//前8位
count-=8;
allCode = allCode.substring（8）;
7 D4 P- F+ H. c, M/ lbos.write（changeString（writeCode））;//写入一个字节
}else{
count+=Code［i］.length（）;
" u; q2 f6 g* vallCode+=Code［i］;
inCode+=Code［i］;
9 \6 K/ `1 \! h- p# Q1 X) K% `) qi++;//严重错误发生地
}
}
//如果不满8位的
if（allCode.length（）》0）{
int len = 8-allCode.length（）;//补零
5 z4 x( c) o0 R( y5 Sfor（int j=0;j
& c0 l6 h: b" D8 \) w/ V4 H. ZallCode+=“0”;
* E0 w, s; A& z' g0 B; X3 s& M}
inCode+=allCode;
bos.write（changeString（allCode））;
}
/ @! J  U; @5 o7 i7 |最后就是把文件中的所有字节按照这种哈弗曼的编码方式保存到文件中，过程类似于上一步（在最后打入末尾补入的0的个数，主要是为了方便解压缩）：Java代码//编码表输出完毕，将文件中的字节按照这种编码方式压缩
- y! O. S: ]' Q# g8 |InputStream ins = new FileInputStream（pathName_former）;
2 v4 L5 v5 P# y  x) bInputStream buf = new BufferedInputStream（ins）;//创建输入流
count = 0;
4 C$ e& X6 D) q9 b( ?0 pwriteCode = “”;
allCode = “”;
# ^3 X( f5 d; g  g
8 c0 `; z" y: P7 `% ?- m
* J1 O) N( E4 W, M$ _' zwhile（buf.available（）》0||count》=8）{
$ G8 F/ r! o0 |7 ^% L% D" hif（count》=8）{//满8
! i, n( Q  J% g; AwriteCode = allCode.substring（0，8）;//前8位
& p6 n! k8 a5 icount-=8;
allCode = allCode.substring（8）;
bos.write（changeString（writeCode））;//写入一个字节
" E6 }6 C' t6 q* G7 ]}else{
; `  `2 z7 z1 S* [6 G( \: aint data = buf.read（）;
! n, x7 E3 o  Y. C4 hcount+=Code［data］.length（）;
8 ^. B% {) p' W0 \) p# }4 wallCode+=Code［data］;
}
}
//如果不满8位的
, A2 `0 s* D3 sif（allCode.length（）》0）{
; Q" c, ?+ C+ d; Uint len = 8-allCode.length（）;//补零
for（int j=0;j
7 a# C( n" a6 w0 Y# D/ f% S3 p3 kallCode+=“0”;
}
7 O4 F: k! @3 Q* kbos.write（changeString（allCode））;
# C2 y; U" A5 L/ m( D- p) ubos.write（len）;//补入了几个0
( `0 j, y3 k: Z8 O7 Q3 l* ~7 w}else{
! b1 K7 l7 D6 |/ Bbos.write（0）;//补入了0个0
3 A1 h- y5 O5 l% I3 L}
到这里，整个压缩过程基本完成了，解压缩就是压缩的逆过程，在此不再赘述，所有的操作都保存在附上源代码中。