20182304 2018-2019-1《程序设计与数据结构》哈夫曼树编码与解码
哈夫曼树简介
- 哈夫曼编码(Huffman Coding)，是Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，主要目的是根据使用频率来最大化节省字符（编码）的存储空间
- 定义：给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近
- 带权路径长度
- 结点的权：在一些应用中,赋予树中结点的一个有某种意义的实数
- 结点的带权路径长度：结点到树根之间的路径长度与该结点上权的乘积
- 树的带权路径长度：定义为树中所有叶结点的带权路径长度之和
- 哈夫曼树并不唯一，但带权路径长度一定是相同的
哈夫曼编码过程记录
要实现的功能:
设有字符集：S={a,b,c,d,e,f,g,h,i,j,k,l,m,n.o.p.q,r,s,t,u,v,w,x,y,z}。
给定一个包含26个英文字母的文件，统计每个字符出现的概率，根据计算的概率构造一颗哈夫曼树。
并完成对英文文件的编码和解码。
要求：
（1）准备一个包含26个英文字母的英文文件（可以不包含标点符号等），统计各个字符的概率
（2）构造哈夫曼树
（3）对英文文件进行编码，输出一个编码后的文件
（4）对编码文件进行解码，输出一个解码后的文件
实现过程:
- 编写节点类，首先设置一个HaffNode类作为实现的基础，为了方便比较,要重写一下compareTo方法
public class HaffNode implements Comparable {
private HaffNode left,right,father;
private char ch;
private int n;
private String code;
public void setLeft(HaffNode left) {
this.left = left;
}
public void setRight(HaffNode right) {
this.right = right;
}
public void setFather(HaffNode father) {
this.father = father;
}
public void setCh(char ch) {
this.ch = ch;
}
public void setN(int sum) {
this.n = sum;
}
public void setCode(String code) {
this.code = code;
}
public HaffNode getLeft() {
return left;
}
public HaffNode getRight() {
return right;
}
public char getCh() {
return ch;
}
public int getN() {
return n;
}
public String getCode() {
return code;
}
public int compareTo(Object o) {
HaffNode a=(HaffNode)o;
if(this.n>a.n)
return 1;
else if(this.n==a.n)
return 0;
else
return -1;
}
- 读取文件
public void read(String address,String name) throws IOException {
int i=0;
File f=new File(address,name);
Reader reader=new FileReader(f);
while(reader.ready()){
a[i++]=(char)reader.read();
}
reader.close();
System.out.print("压缩前：");
for(int k=0;k<a.length;k++){
System.out.print(a[k]);
}
System.out.println();
}
- 构造哈夫曼树类，实现编码读取、储存，哈夫曼树的根节点，保持编码值的数组等
private static char[] ch={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',' '};
//包含空格
private char[] a=new char[300];
private int[] sum=new int[27];
private HaffNode root;
private String[] strings=new String[28];//保存编码
private LinkedList treelist=new LinkedList<HaffNode>();//列表
- 用createTree构造一棵树
public LinkedList createTree() {
count();//匹配
for (int i = 0; i < 27; i++) {
HaffNode node = new HaffNode();
node.setCh(ch[i]);
node.setN(sum[i]);
treelist.add(i, node);
}
Collections.sort(treelist);
while (treelist.size() > 1) {//获得权值最小节点
HaffNode first = (HaffNode) treelist.removeFirst();
HaffNode second = (HaffNode) treelist.removeFirst();
//构造成父节点
HaffNode parent = new HaffNode();
parent.setN(first.getN() + second.getN());
parent.setLeft(first);
parent.setRight(second);
//把父节点添加进列表，并重新排序
treelist.add(parent);
Collections.sort(treelist);
}
root= (HaffNode) treelist.getFirst();
return treelist;
}
//频数统计，计算
public void count(){
for(int k=0;k<a.length;k++){
for (int j=0;j<ch.length;j++){
if(a[k]==ch[j])
sum[j]++;
}
}
}
- 根据字符找到节点，从而找到该字符编码
public HaffNode search(HaffNode root,char c) {
if(root.getCh()==c){
return root;
}
if(root.getLeft()!=null||root.getRight()!=null) {
HaffNode a=search(root.getLeft(),c);
HaffNode b=search(root.getRight(),c);
if(a!=null)
return a;
if(b!=null)
return b;
}
return null;
}
public HaffNode getRoot() {
return root;
}
- 文件压缩与写入编码
public void Compress(String path) throws IOException {
String result="";
for(int i=0;i<27;i++){
result+=ch[i]+""+sum[i]+",";
}
String content="";
for(int i=0;i<a.length;i++){
for(int k=0;k<ch.length;k++){
if(a[i]==ch[k])
content+=search(root,ch[k]).getCode()+" ";
}
}
result+=content;
File f=new File(path);
if(!f.exists()){
f.createNewFile();
}
System.out.println("编码结果："+content);
Writer writer=new FileWriter(f);
BufferedWriter bufferedWriter=new BufferedWriter(writer);
bufferedWriter.write(result);
bufferedWriter.flush();
bufferedWriter.close();
}
- 读取文件、解压缩、再次写入文件
public void read2(String address,String name) throws IOException {
//读取文件
File file=new File(address,name);
Reader reader=new FileReader(file);
BufferedReader bufferedReader=new BufferedReader((new InputStreamReader(new FileInputStream(file),"GBK")));
String str="";
String temp="";
while((temp=bufferedReader.readLine())!=null){
System.out.println("压缩后文件内容："+temp);
str=temp;
}
//获取每个字符的频数，逗号分割
StringTokenizer s =new StringTokenizer(str,",");
int i=0;
while (s.hasMoreTokens()){
strings[i++]=s.nextToken();
}
}
public LinkedList createTree2(){
for(int i=0;i<27;i++){
HaffNode temp=new HaffNode();
temp.setCh(strings[i].charAt(0));
temp.setN(strings[i].charAt(1)-'0');
treelist.add(temp);
}
Collections.sort(treelist);
while (treelist.size() > 1) {
//获得两个权值最小的节点
HaffNode first = (HaffNode) treelist.removeFirst();
HaffNode second = (HaffNode) treelist.removeFirst();
//构造成父节点
HaffNode parent = new HaffNode();
parent.setN(first.getN() + second.getN());
parent.setLeft(first);
parent.setRight(second);
//添加进列表，并重新排序
treelist.add(parent);
Collections.sort(treelist);
}
root= (HaffNode) treelist.getFirst();
return treelist;
}
public void reCompress(String address) throws IOException {
String t=strings[27];
String result="";
StringTokenizer stringTokenizer=new StringTokenizer(t);
while(stringTokenizer.hasMoreTokens()){
String temp=stringTokenizer.nextToken();
result+=search2(root,temp).getCh();
}
System.out.println("解码后："+result);
File f=new File(address);
Writer writer=new FileWriter(f);
BufferedWriter bufferedWriter=new BufferedWriter(writer);
bufferedWriter.write(result);
bufferedWriter.flush();
bufferedWriter.close();
}
//根据字符找到节点，从而找到该字符编码
public HaffNode search2(HaffNode root,String code) {
if (root.getCode() == null) {
if (root.getLeft() != null || root.getRight() != null) {
HaffNode a = search2(root.getLeft(), code);
HaffNode b = search2(root.getRight(), code);
if (a != null)
return a;
if (b != null)
return b;
}
return null;
}
else if(root.getCode().equals(code)){
return root;
}
return null;
}
- 测试类
public static void main(String[] args) throws IOException {
HaffmanTree tree1=new HaffmanTree();
//读取文件
tree1.read("C:\\Users\\666\\abcd","zzzz.txt");
//构建哈夫曼树
LinkedList temp=tree1.createTree();
//获得节点编码
for(int i=0;i<temp.size();i++){
tree1.getCode((HaffNode) temp.get(i),"");
}
//压缩
tree1.Compress("D:\\ppp");
HaffmanTree tree2=new HaffmanTree();
//读写压缩编码
tree2.read2("D:","ppp");
LinkedList temp2=tree2.createTree2();
for(int i=0;i<temp2.size();i++)
tree2.getCode((HaffNode) temp2.get(i),"");
//解压缩
tree2.reCompress("C:\\Users\\666\\abcd\\zzzz.txt");
结果：
