数据结构与算法——赫夫曼树和赫夫曼编码的java代码实现

赫夫曼编码的原理

对于我们日常操作压缩文件来说，通常都是将文件中的字符转换成压缩后的格式，但为什么能够解压回来，那是因为压缩后的数据形式和元原字符唯一对应。
因为计算机总是以0/1保存文件，那编码过程中也是将文件转化成更小的0/1序列，起到压缩的作用。比如：
对于一个字符a来说，计算机是用8bit来保存字符的，如果我们可以唯一用一个bit的0来表示这个a，那这一个字符就为计算机节省了7bit的空间。

基础概念

当树中的结点被赋予表示某种意义的数值，我们称之为该结点的权。
从树的根结点到任意结点的路径长度（经过的边数）与该结点上权值的乘积称为该结点的带权路径长度。
树中所有叶子结点的带权路径长度之和称为该树的带权路径长度（WPL）。
当带权路径长度最小二叉树被称为哈夫曼树，也称为最优二叉树。
举个例子：
计算下面三棵树。每棵树有四个叶子节点a、b、c、d,分别取带权值：7、5、2、4

WPL(a)：72+52+22+42=36
WPL(b)：42+73+53+21=46
WPL©：71+52+23+43=35
叶子结点带权路径长度和最小的树就是最优二叉树 / 哈夫曼树

2、赫夫曼树的构造

上面可以知道图C就为哈夫曼树，又称为最优二叉树。指的是带权路径长度最短的树。那么哈夫曼树应该如何实现呢？

其核心思想：每次取数值最小的两个结点，将之组成一颗子树，并移除原来的两个点。
哈夫曼树的构造：
哈夫曼树在构造时每次从备选节点中挑出两个权值最小的节点进行构造，每次构造完成后会生成新的节点，将构造的节点从备选节点中删除并将新产生的节点加入到备选节点中。新产生的节点权值为参与构造的两个节点权值之和。举例如下：

备选节点为a,b,c,d，权值分别为7,5,2,4
选出c和d进行构造(权值最小),生成新节点为e(权值为6)，备选节点变为7,5,6
选出b和e进行构造，生成新节点f(权值为11),备选节点为7,11
将最后的7和11节点进行构造，最后生成如图所示的哈夫曼树

赫夫曼树唯一标识字符

在给定一些字符的时候，我们需要用二进制编码f(x)表示字符x，且在识别的过程中不会产生冲突，那很容易理解的一点是对于任意f(a)来说绝对不会出现一个f(b)使得f(a)可以作为f(b)的前缀。
例如：
a: 110表示
b: 1100表示
那么对于一个压缩后的编码1101100来说当识别到110的时候，无法判断这个是否已经是a了还是否继续识别，因为是存在b的可能性的，这就是所谓的编码冲突。

将这个放到树上来理解，从根节点出发0表示向左子树走，1表示向右子树走，最后走到最低端的叶子节点就是对这个叶子节点字符对应的编码。
按照上述，那么在这个树上一定不可能出现在朝一个叶子上的字符往下走的过程中遇到其他编码的字符，因为这样的结果一定会产生前缀。
所以这是哈夫曼树的一个重要特性。

赫夫曼在编码中的应用

在电文传输中，需要将电文中出现的每个字符进行二进制编码。在设计编码时需要遵守两个原则：
（1）发送方传输的二进制编码，到接收方解码后必须具有唯一性，即解码结果与发送方发送的电文完全一样；
（2）发送的二进制编码尽可能地短。下面我们介绍两种编码的方式。

等长编码
这种编码方式的特点是每个字符的编码长度相同（编码长度就是每个编码所含的二进制位数）。假设字符集只含有4个字符A，B，C，D，用二进制两位表示的编码分别为00，01，10，11。若现在有一段电文为：ABACCDA，则应发送二进制序列：00010010101100，总长度为14位。当接收方接收到这段电文后，将按两位一段进行译码。这种编码的特点是译码简单且具有唯一性，但编码长度并不是最短的。

不等长编码
在传送电文时，为了使其二进制位数尽可能地少，可以将每个字符的编码设计为不等长的，使用频度较高的字符分配一个相对比较短的编码，使用频度较低的字符分配一个比较长的编码。例如，可以为A，B，C，D四个字符分别分配0，00，1，01，并可将上述电文用二进制序列：000011010发送，其长度只有9个二进制位，但随之带来了一个问题，接收方接到这段电文后无法进行译码，因为无法断定前面4个0是4个A，1个B、2个A，还是2个B，即译码不唯一，因此这种编码方法不可使用。

因此，为了设计长短不等的编码，以便减少电文的总长，还必须考虑编码的唯一性，即在建立不等长编码时必须使任何一个字符的编码都不是另一个字符的前缀，这宗编码称为前缀编码（prefix code）
（1）利用字符集中每个字符的使用频率作为权值构造一个哈夫曼树；
（2）从根结点开始，为到每个叶子结点路径上的左分支赋予0，右分支赋予1，并从根到叶子方向形成该叶子结点的编码

哈夫曼树的构造

package demo7;

public class Node implements Comparable<Node>{
		int value;
		Node left;
		Node right;
		
		public Node(int value) {
			this.value=value;
		}
		
		public int compareTo(Node o) {
			return this.value=o.value;
		}
}


package demo7;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestHuffmanTree {
	public static void main(String[] args) {
		int []arr= {3,7,8,29,5,11,23,14};
		Node node=creatHaffmanTree(arr);
		System.out.println(node);
	} 
	
	//创建二叉树
	public  static Node creatHaffmanTree(int []arr) {
		//先使用数组中所有的元素创建若干个二叉树（只有一个节点）
		List<Node> nodes=new ArrayList<>();
		for(int value:arr) {
			nodes.add(new Node(value));
		}
		//循环处理
		while(nodes.size()>1) {
		//排序
			Collections.sort(nodes);
		//取出来权值最小的两个二叉树
			Node left=nodes.get(nodes.size()-1);
			//取出来权值次小的两个二叉树
			Node right=nodes.get(nodes.size()-2);
		//创建一颗新的二叉树
			Node parent=new Node(left.value+right.value);
		//把取出来的两个二叉树集合中移除
			nodes.remove(left);
			nodes.remove(right);
		//放入原来的二叉树集合中
			nodes.add(parent);
		}
		System.out.println(nodes);
		return  nodes.get(0);
	}
}

哈夫曼编码的创建压缩以及解压的实现

package demo8;

public class Node implements Comparable<Node> {
	Byte data;
	int weight;
	Node left;
	Node right;
	public Node(Byte data,int weight) {
		this.data=data;
		this.weight=weight;
	}
	
	@Override
	public int compareTo(Node o) {
		return o.weight-this.weight;
	}
}

package demo8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestHaffmanCode {
public static void main(String[]args) {
	String msg="can you can a  can as a can canner can a can";
	byte[] bytes=msg.getBytes();
	//进行赫夫曼编码
	byte[] b=huffmanZip(bytes);
	//使用赫夫曼进行解码
	byte[] newBytes=decode(huffCodes,b);
	System.out.println(new String(newBytes));
}

/*
 * 使用指定的赫夫曼编码表进行解码
 */
private static byte[] decode(Map<Byte, String> huffCodes, byte[] bytes) {
	StringBuilder sb=new StringBuilder();
	// 把byte数组转化为一个二进制的字符串
	for(int i=0;i<bytes.length;i++) {
		byte b=bytes[i];
		//是否是最后一个
		boolean flag = (i==bytes.length-1);
		sb.append(byteToBitStr(!flag,b));
	}
	System.out.println(sb.toString());
	//把字符串按照指定的赫夫曼编码进行解码
	//把赫夫曼编码的健值对进行调换
	Map<String,Byte> map=new HashMap<>();
	for(Map.Entry<Byte,String>entry:huffCodes.entrySet()) {
		map.put(entry.getValue(),entry.getKey());
		
	}
	//创建一个集合，用来存byte
	List<Byte>list=new ArrayList<>();
	//处理字符串
	for(int i=0;i<sb.length();) {
		int count=1;
		boolean flag=true;
		Byte b=null;
		while(flag) {
		String key=sb.substring(i, i+count);
		 b=map.get(key);
		if(b==null) {
			count++;
		}else {
			flag=false;
			}
		}
		i+=count;
	}
	//把集合转换为数组
	byte[] b=new byte[list.size()];
	for(int i=0;i<b.length;i++) {
		b[i]=list.get(i);
	}
	return b;
}

private static String byteToBitStr(boolean flag,byte b) {
	int temp=b;
	if(flag) {
	temp |=256;
	}
	String str=Integer.toBinaryString(temp);
	if(flag) {
		return str.substring(str.length()-8);
	}else {
		return str;
	}
}

/*
 * 进行赫夫曼编码压缩方法
 */
private static byte[] huffmanZip(byte[] bytes) {
	//先统计每一个Byte出现的次数，并放入一个集合中
	List<Node> nodes=getNodes(bytes);
	//创建一颗赫夫曼树
	Node tree=creatHaffmanTree(nodes);
	//创建一个赫夫曼编码表
	Map<Byte,String>huffCodes=getCodes(tree);
	//System.out.println(huffCodes);
	//编码
	byte[] b=zip(bytes,huffCodes);
	return b;
}

/*
 * 进行赫夫曼编码
 */
private static byte[] zip(byte[] bytes, Map<Byte, String> huffCodes) {
	StringBuilder sb=new StringBuilder();
	//把需要压缩的byte素组处理成一个二进制的字符串
	for(byte b:bytes) {
		sb.append(huffCodes.get(b));
	}
	//定义长度
	int len;
	if(sb.length()%8==0) {
		len=sb.length()/8;
	}else {
		len=sb.length()/8+1;
	}
	//用于存储压缩后的Byte
	byte[] by=new byte[len];
	//记录新的Byte的位置
	int index=0;
	for(int i=0;i<sb.length();i+=8) {
		String strByte;
		if(i+8>sb.length()) {
			strByte=sb.substring(i);
		}else {
			 strByte=sb.substring(i,i+8);
		}
		byte byt=(byte)Integer.parseInt(strByte,2);
		by[index]=byt;
		index++;
	}
	return by;
}
//用于临时存储路径
static StringBuilder sb=new StringBuilder();
//用于存储赫夫曼编码
static Map<Byte ,String> huffCodes=new HashMap<>();
/*
 * 根据赫夫曼树获取赫夫曼编码
 */
private static Map<Byte, String> getCodes(Node tree) {
	// TODO Auto-generated method stub
	if(tree==null) {
		return null;
	}
	getCodes(tree.left,"0",sb);
	getCodes(tree.right,"1",sb);
	return huffCodes;
}

private static void getCodes(Node node,String code,StringBuilder sb) {
	StringBuilder sb2=new StringBuilder(sb);
	sb2.append(code);
	if(node.data==null) {
		getCodes(node.left,"0",sb2);
		getCodes(node.right,"1",sb2);
	}else {
		huffCodes.put(node.data, sb2.toString());
	}
}
/*
 * 创建赫夫曼树
 */
private static Node creatHaffmanTree(List<Node> nodes) {
	// TODO Auto-generated method stub
	while(nodes.size()>1) {
		//排序
		Collections.sort(nodes);
		//取出两个权值最低的二叉树
		Node left=nodes.get(nodes.size()-1);
		Node right=nodes.get(nodes.size()-2);
		//创建一颗新的二叉树
		Node parent=new Node(null,left.weight+right.weight);
		//把之前取出来的二叉树设置为新创建的二叉树的子树
		parent.left=left;
		parent.right=right;
		//把前面取出来的二叉树删除
		nodes.remove(left);
		nodes.remove(right);
		//把新创建的二叉树放入集合中
		nodes.add(parent);
	}
	return nodes.get(0);
}

/*
 * 把byte数组转为list集合
 */
private static List<Node> getNodes(byte[] bytes) {
	// TODO Auto-generated method stub
	List<Node> nodes=new ArrayList<>();
	Map<Byte,Integer> counts=new HashMap<>();
	//统计次数
	for(byte b:bytes) {
		Integer	count=counts.get(b);
		if(count==null) {
			counts.put(b, 1);
		}else {
			counts.put(b, count+1);
		}
	 
	}
	//把每一个键值对转为一个Node对象
	for(Map.Entry<Byte, Integer>entry:counts.entrySet()) {
		nodes.add(new Node(entry.getKey(),entry.getValue()));
		}
	return nodes;
	}
}