数据结构（Java实现）-图解哈夫曼树（最优二叉树）与哈夫曼编码原理（使用哈夫曼编码压缩并解压数据）_java 实现哈夫曼树

1、哈夫曼树

1.1哈夫曼树基本介绍

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl) 达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)

• 路径：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径
• 路径长度：通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1
• 结点的权：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权
• 结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积
• 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length)

比如：
对于下图二叉树结构中的13结点
权值：13
路径：1——>5——>13
路径长度：3-1=2
带权路径长度：13 x 2 = 26
该二叉树的带权路径长度为：13x2+7x2+8x2+3x2=62

哈夫曼树的特点：

• 权值越大的结点离根结点越近
• 树的带权路径长度WPL最小

1.2哈夫曼树的创建

构成哈夫曼树的步骤：

1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一棵最简单的二叉树
2. 取出根节点权值最小的两棵二叉树
3. 组成一棵新的二叉树, 该新的二叉树的根节点的权值是前面两棵二叉树根节点权值的和
4. 再将这棵新的二叉树，以根节点的权值大小与之前剩下的二叉树进行再次排序，
5. 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一棵哈夫曼树

题目：要求把数列 {13, 7, 8, 3, 29, 6, 1}，转成一棵哈夫曼树.

图解：
1、排序：1, 3, 6, 7, 8, 13, 29
2、找到最小根结点值最小的两棵二叉树，1,3构建如下二叉树
3、再进行排序：4,6,7,8,13,29 取4,6构建如下二叉树

4、再进行排序：7,8,10,13,29 取7,8构建如下二叉树

5、再进行排序：10,13,15,29 取10,13构建如下二叉树

6、再进行排序：15,23,29 取15,23 构建如下二叉树

7、再进行排序：29,38 取29,38 得到最终的哈夫曼树

代码实现：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
// 创建结点类
// 为了让Node 对象持续排序Collections集合排序
// 让Node 实现Comparable接口
class Node implements Comparable<Node> {
	int value; // 结点权值
	Node left; // 指向左子结点
	Node right; // 指向右子结点
	//写一个前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}	
	public Node(int value) {
		this.value = value;
	}
	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}
	@Override
	//一个内部比较器实现权值集合排序
	public int compareTo(Node o) {
		// TODO Auto-generated method stub
		// 表示从小到大排序
		return this.value - o.value;
	}

}
public class HuffmanTree {
	public static void main(String[] args) {
		int arr[] = { 13, 7, 8, 3, 29, 6, 1 };
		Node root = createHuffmanTree(arr);	
		//测试一把
		System.out.println("前序遍历已经创建好的哈夫曼树：");
		preOrder(root); //
		
	}	
	//编写一个前序遍历的方法
	public static void preOrder(Node root) {
		if(root != null) {
			root.preOrder();
		}else{
			System.out.println("是空树，不能遍历~~");
		}
	}
	// 创建赫夫曼树的方法
	/**
	 * 
	 * @param arr 需要创建成哈夫曼树的数组
	 * @return 创建好后的赫夫曼树的root结点
	 */
	public static Node createHuffmanTree(int[] arr) {
		// 第一步为了操作方便
		// 1. 遍历 arr 数组
		// 2. 将arr的每个元素构成成一个Node
		// 3. 将每个Node 放入到ArrayList中
		int num=0;//记录排序的次数
		List<Node> nodes = new ArrayList<Node>();
		for (int value : arr) {
			nodes.add(new Node(value));
		}
		
		//我们处理的过程是一个循环的过程	
		while(nodes.size() > 1) {		
			//排序 从小到大 
			Collections.sort(nodes);		
			num++;
			System.out.println("第"+num+"次排序nodes =" + nodes);		
			//取出根节点权值最小的两颗二叉树 
			//(1) 取出权值最小的结点（二叉树）
			Node leftNode = nodes.get(0);
			//(2) 取出权值第二小的结点（二叉树）
			Node rightNode = nodes.get(1);
			
			//(3)构建一颗新的二叉树
			Node parent = new Node(leftNode.value + rightNode.value);
			parent.left = leftNode;
			parent.right = rightNode;
			
			//(4)从ArrayList删除处理过的二叉树
			nodes.remove(leftNode);
			nodes.remove(rightNode);
			//(5)将parent加入到nodes
			nodes.add(parent);
		}	
		//返回哈夫曼树的root结点
		return nodes.get(0);		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

第1次排序nodes =[Node [value=1], Node [value=3], Node [value=6], Node [value=7], Node [value=8], Node [value=13], Node [value=29]]
第2次排序nodes =[Node [value=4], Node [value=6], Node [value=7], Node [value=8], Node [value=13], Node [value=29]]
第3次排序nodes =[Node [value=7], Node [value=8], Node [value=10], Node [value=13], Node [value=29]]
第4次排序nodes =[Node [value=10], Node [value=13], Node [value=15], Node [value=29]]
第5次排序nodes =[Node [value=15], Node [value=23], Node [value=29]]
第6次排序nodes =[Node [value=29], Node [value=38]]
前序遍历已经创建好的哈夫曼树：
Node [value=67]
Node [value=29]
Node [value=38]
Node [value=15]
Node [value=7]
Node [value=8]
Node [value=23]
Node [value=10]
Node [value=4]
Node [value=1]
Node [value=3]
Node [value=6]
Node [value=13]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、哈夫曼编码

2.1哈夫曼编码的基本介绍

哈夫曼编码(Huffman Coding)是一种编码方式, 属于一种程序算法
哈夫曼编码是哈夫曼树在电讯通信中的经典的应用之一。
赫夫曼编码广泛地用于数据文件压缩，其压缩率通常在20%～90%之间
赫夫曼码是可变字长编码(VLC) 的一种，Huffman于1952年提出一种编码方法，称之为最佳编码

2.2编码原理解析

1、通信领域中信息的处理方式1-定长编码:

缺点：所占字符长度太长消耗大量内存空间

2、通信领域中信息的处理方式2-变长编码：

缺点：不是前缀编码，编码匹配时会出现多义性（比如：上图中字符“a”的编码是1空格对应的编码是0，在解码过程中会把10对应的“i”解成“a”和空格）

前缀编码：字符的编码都不能是其他字符编码的前缀， 即不能匹配到重复的编码

3、通信领域中信息的处理方式3-赫夫曼编码：
i like like like java do you like a java // 共40个字符(包括空格)
d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9 // 各个字符对应的个数
按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值.

根据赫夫曼树，给各个字符,规定编码 (前缀编码)， 向左的路径为0 向右的路径为1 ， 编码如下:
o: 1000 u: 10010 d: 100110 y: 100111 i: 101 a : 110
k: 1110 e: 1111 j: 0000 v: 0001 l: 001 : 01

按照上面的赫夫曼编码，我们的"i like like like java do you like a java" 字符串对应的编码为 (注意这里我们使用的无损压缩)
1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110
通过赫夫曼编码处理 长度为 133

说明：

• 原来长度是 359 , 压缩了 (359-133) / 359 = 62.9%
• 此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性
• 赫夫曼编码是无损处理方案

注意：
我们发现在构建哈夫曼树的过程中会有权值相同的结点，这时候就会产生问题，两个结点构成的新二叉树的根结点的权值与还未进出处理的多个结点权值相同，那这时到底应该排在它们的前面，中间还是后面呢？
（通常是排在前面的）
这种情况下排序方式的不同导致最后得到的哈夫曼树也不同，进而导致哈夫曼编码方式也会不同
比如：上面的图片中的哈夫曼树是把已经构建好的二叉树排在权值相同的二叉树前面得到的，而下面这张图中的是排在后面得到的

虽然会导致编码方式不同，但是最后的编码长度还是133是不会变的

2.3 哈夫曼编码的实现

功能：需要创建 “i like like like java do you like a java” 对应的哈夫曼树
思路:
(1) Node { data (存放字符对应的ASCII码)， weight (权值)， left 和 right }
(2) 得到 “i like like like java do you like a java” 对应的 byte[] 数组
(3) 编写一个方法，将准备构建哈夫曼树的Node 节点放到 List , 形式 :[Node[date=97 ,weight = 5], Node[]date=32,weight = 9]…], 体现 d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9
(4) 可以通过List 创建对应的哈夫曼树
(5)向左的路径为0 向右的路径为1 ,得到哈夫曼编码表

生成哈夫曼树对应的哈夫曼编码 , 如下表:
=01 a=100 d=11000 u=11001 e=1110 v=11011 i=101 y=11010 j=0010 k=1111 l=000 o=0011

代码实现：

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

//创建Node ,待数据和权值
class Node implements Comparable<Node>  {
	Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
	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 this.weight - o.weight;
	}
	public String toString() {
		return "Node [data = " + data + " weight=" + weight + "]";
	}
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
}

public class HuffmanCode{
	public static void main(String[] args) {	
		String content = "i like like like java do you like a java";
		byte[] contentBytes = content.getBytes();
		System.out.println(contentBytes.length); //40
		List<Node> nodes = getNodes(contentBytes);
		System.out.println("nodes=" + nodes);
		
		//测试一把，创建的哈夫曼树
		System.out.println("哈夫曼树");
		Node huffmanTreeRoot = createHuffmanTree(nodes);
		System.out.println("前序遍历");
		huffmanTreeRoot.preOrder();
		
		//测试一把是否生成了对应的哈夫曼编码
		Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
		System.out.println("~生成的哈夫曼编码表:" );
		System.out.println( huffmanCodes);
	}
	
	//生成哈夫曼树对应的哈夫曼编码
		//思路:
		//1. 将哈夫曼编码表存放在 Map<Byte,String> 形式
		//   生成的哈夫曼编码表{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
		static Map<Byte, String> huffmanCodes = new HashMap<Byte,String>();
		//2. 在生成哈夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
		static StringBuilder stringBuilder = new StringBuilder();	
		//为了调用方便,重载 getCodes
		private static Map<Byte, String> getCodes(Node root) {
			if(root == null) {
				return null;
			}
			//处理root的左子树
			getCodes(root.left, "0", stringBuilder);
			//处理root的右子树
			getCodes(root.right, "1", stringBuilder);
			return huffmanCodes;
		}
		
		/**
		 * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合
		 * @param node  传入结点
		 * @param code  路径： 左子结点是 0, 右子结点 1
		 * @param stringBuilder 用于拼接路径
		 */
		private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
			StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
			//将code 加入到 stringBuilder2
			stringBuilder2.append(code);
			if(node != null) { //如果node == null不处理
				//判断当前node 是叶子结点还是非叶子结点
				if(node.data == null) { //非叶子结点
					//递归处理
					//向左递归
					getCodes(node.left, "0", stringBuilder2);
					//向右递归
					getCodes(node.right, "1", stringBuilder2);
				} else { //说明是一个叶子结点
					//就表示找到某个叶子结点的最后
					huffmanCodes.put(node.data, stringBuilder2.toString());
				}
			}
		}
		
	//前序遍历的方法
	private static void preOrder(Node root) {
		if(root != null) {
			root.preOrder();
		}else {
			System.out.println("哈夫曼树为空");
		}
	}
	
	/**
	 * 
	 * @param bytes 接收字节数组
	 * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......],
	 */
	private static List<Node> getNodes(byte[] bytes) {		
		//1创建一个ArrayList
		ArrayList<Node> nodes = new ArrayList<Node>();
		
		//遍历 bytes , 统计 每一个byte出现的次数->map[key,value]
		Map<Byte, Integer> counts = new HashMap<>();
		for (byte b : bytes) {
			Integer count = counts.get(b);
			if (count == null) { // Map还没有这个字符数据,第一次
				counts.put(b, 1);
			} else {
				counts.put(b, count + 1);
			}
		}		
		//把每一个键值对转成一个Node 对象，并加入到nodes集合
		//遍历map
		for(Map.Entry<Byte, Integer> entry: counts.entrySet()) {
			nodes.add(new Node(entry.getKey(), entry.getValue()));
		}
		return nodes;		
	}		
	//可以通过List 创建对应的哈夫曼树
	private static Node createHuffmanTree(List<Node> nodes) {		
		while(nodes.size() > 1) {
			//排序, 从小到大
			Collections.sort(nodes);
			//取出第一颗最小的二叉树
			Node leftNode = nodes.get(0);
			//取出第二颗最小的二叉树
			Node rightNode = nodes.get(1);
			//创建一颗新的二叉树,它的根节点 没有data, 只有权值
			Node parent = new Node(null, leftNode.weight + rightNode.weight);
			parent.left = leftNode;
			parent.right = rightNode;
			
			//将已经处理的两颗二叉树从nodes删除
			nodes.remove(leftNode);
			nodes.remove(rightNode);
			//将新的二叉树，加入到nodes
			nodes.add(parent);
			
		}
		//nodes 最后的结点，就是哈夫曼树的根结点
		return nodes.get(0);		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

40
nodes=[Node [data = 32 weight=9], Node [data = 97 weight=5], Node [data = 100 weight=1], Node [data = 101 weight=4], Node [data = 117 weight=1], Node [data = 118 weight=2], Node [data = 105 weight=5], Node [data = 121 weight=1], Node [data = 106 weight=2], Node [data = 107 weight=4], Node [data = 108 weight=4], Node [data = 111 weight=2]]
哈夫曼树
前序遍历
Node [data = null weight=40]
Node [data = null weight=17]
Node [data = null weight=8]
Node [data = 108 weight=4]
Node [data = null weight=4]
Node [data = 106 weight=2]
Node [data = 111 weight=2]
Node [data = 32 weight=9]
Node [data = null weight=23]
Node [data = null weight=10]
Node [data = 97 weight=5]
Node [data = 105 weight=5]
Node [data = null weight=13]
Node [data = null weight=5]
Node [data = null weight=2]
Node [data = 100 weight=1]
Node [data = 117 weight=1]
Node [data = null weight=3]
Node [data = 121 weight=1]
Node [data = 118 weight=2]
Node [data = null weight=8]
Node [data = 101 weight=4]
Node [data = 107 weight=4]
~生成的哈夫曼编码表:
{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2.4 使用哈夫曼编码实现数据压缩与解压

上面已经生成哈夫曼树对应的哈夫曼编码 , 如下表:
=01 a=100 d=11000 u=11001 e=1110 v=11011 i=101 y=11010 j=0010 k=1111 l=000 o=0011

现在使用哈夫曼编码来生成哈夫曼编码数据 ,即按照上面的哈夫曼编码，将"i like like like java do you like a java" 字符串生成对应的编码数据, 形式如下：
1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100

压缩数据：将上面得到的字符串哈夫曼编码转成一个压缩后的字节数组
解压数据：将压缩得到的字节数组解压为原字符串

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

//创建Node ,待数据和权值
class Node implements Comparable<Node>  {
	Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
	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 this.weight - o.weight;
	}
	public String toString() {
		return "Node [data = " + data + " weight=" + weight + "]";
	}
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
}

public class test{
	public static void main(String[] args) {	
		String content = "i like like like java do you like a java";
		byte[] contentBytes = content.getBytes();
		System.out.println(contentBytes.length); //40
		List<Node> nodes = getNodes(contentBytes);
		System.out.println("nodes=" + nodes);
		
		//测试一把，创建的哈夫曼树
		System.out.println("哈夫曼树");
		Node huffmanTreeRoot = createHuffmanTree(nodes);
		System.out.println("前序遍历");
		huffmanTreeRoot.preOrder();
		
		//测试一把是否生成了对应的哈夫曼编码
		Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
		System.out.println("~生成的哈夫曼编码表:" );
		System.out.println( huffmanCodes);
		
		System.out.println(content);
		//测试,得到哈夫曼编码处理后的byte[]数组
		byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
		System.out.println("huffmanCodeBytes=" + Arrays.toString(huffmanCodeBytes));//17
		
		//解压数据
		System.out.println("将压缩后的Byte数组解压为原字符串：");
		byte[] sourceBytes = decode(huffmanCodes,huffmanCodeBytes);
		System.out.println("原来的字符串="+ new String(sourceBytes));
	}
	//完成数据的解压
		//思路
		//1. 将huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
		//   重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."
		//2.  赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码  =》 "i like like like java do you like a java"
		//编写一个方法，完成对压缩数据的解码
		/**
		 * 
		 * @param huffmanCodes 哈夫曼编码表 map
		 * @param huffmanBytes 哈夫曼编码得到的字节数组
		 * @return 就是原来的字符串对应的数组
		 */
		private static byte[] decode(Map<Byte,String> huffmanCodes, byte[] huffmanBytes) {
			//1. 先得到 huffmanBytes 对应的 二进制的字符串 ， 形式 1010100010111...
			StringBuilder stringBuilder = new StringBuilder();
			//将byte数组转成二进制的字符串
			for(int i = 0; i < huffmanBytes.length; i++) {
				byte b = huffmanBytes[i];
				//判断是不是最后一个字节
				boolean flag = (i == huffmanBytes.length - 1);
				stringBuilder.append(byteToBitString(!flag, b));
			}
			//把字符串安装指定的哈夫曼编码进行解码
			//把哈夫曼编码表进行调换，因为反向查询 a->100 100->a
			Map<String, Byte>  map = new HashMap<String,Byte>();
			for(Map.Entry<Byte, String> entry: huffmanCodes.entrySet()) {
				map.put(entry.getValue(), entry.getKey());
			}
			
			//创建要给集合，存放byte
			List<Byte> list = new ArrayList<>();
			//i 可以理解成就是索引,扫描 stringBuilder 
			for(int  i = 0; i < stringBuilder.length(); ) {
				int count = 1; // 小的计数器
				boolean flag = true;
				Byte b = null;
				
				while(flag) {
					//1010100010111...
					//递增的取出 key 1 
					String key = stringBuilder.substring(i, i+count);//i 不动，让count移动，指定匹配到一个字符
					b = map.get(key);
					if(b == null) {//说明没有匹配到
						count++;
					}else {
						//匹配到
						flag = false;
					}
				}
				list.add(b);
				i += count;//i 直接移动到 count	
			}
			//当for循环结束后，我们list中就存放了所有的字符  "i like like like java do you like a java"
			//把list 中的数据放入到byte[] 并返回
			byte b[] = new byte[list.size()];
			for(int i = 0;i < b.length; i++) {
				b[i] = list.get(i);
			}
			return b;
			
		}
		/**
		 * 将一个byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的Java基础 二进制的原码，反码，补码
		 * @param b 传入的 byte
		 * @param flag 标志是否需要补高位如果是true ，表示需要补高位，如果是false表示不补, 如果是最后一个字节，无需补高位
		 * @return 是该b 对应的二进制的字符串，（注意是按补码返回）
		 */
		private static String byteToBitString(boolean flag, byte b) {
			//使用变量保存 b
			int temp = b; //将 b 转成 int
			//如果是正数我们还存在补高位
			if(flag) {
				temp |= 256; //按位与 256  1 0000 0000  | 0000 0001 => 1 0000 0001
			}
			String str = Integer.toBinaryString(temp); //返回的是temp对应的二进制的补码
			if(flag) {
				return str.substring(str.length() - 8);
			} else {
				return str;
			}
		}
	//编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个哈夫曼编码 压缩后的byte[]
		/**
		 * 
		 * @param bytes 这时原始的字符串对应的 byte[]
		 * @param huffmanCodes 生成的赫夫曼编码map
		 * @return 返回赫夫曼编码处理后的 byte[] 
		 * 举例： String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes();
		 * 返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
		 * => 对应的 byte[] huffmanCodeBytes  ，即 8位对应一个 byte,放入到 huffmanCodeBytes
		 * huffmanCodeBytes[0] =  10101000(补码) => byte  [推导  10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ]
		 * huffmanCodeBytes[1] = -88
		 */
		private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
			
			//1.利用 huffmanCodes 将  bytes 转成  赫夫曼编码对应的字符串
			StringBuilder stringBuilder = new StringBuilder();
			//遍历bytes 数组 
			for(byte b: bytes) {
				stringBuilder.append(huffmanCodes.get(b));
			}
			
			System.out.println("字符串对应的哈夫曼编码：" + stringBuilder.toString());
			
			//将 "1010100010111111110..." 转成 byte[]
			
			//统计返回  byte[] huffmanCodeBytes 长度
			//一句话 int len = (stringBuilder.length() + 7) / 8;
			int len;
			if(stringBuilder.length() % 8 == 0) {
				len = stringBuilder.length() / 8;
			} else {
				len = stringBuilder.length() / 8 + 1;
			}
			//创建 存储压缩后的 byte数组
			byte[] huffmanCodeBytes = new byte[len];
			int index = 0;//记录是第几个byte
			for (int i = 0; i < stringBuilder.length(); i += 8) { //因为是每8位对应一个byte,所以步长 +8
					String strByte;
					if(i+8 > stringBuilder.length()) {//不够8位
						strByte = stringBuilder.substring(i);
					}else{
						strByte = stringBuilder.substring(i, i + 8);
					}	
					//将strByte 转成一个byte,放入到 huffmanCodeBytes
					huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte, 2);
					index++;
			}
			return huffmanCodeBytes;
		}
	//生成赫夫曼树对应的赫夫曼编码
		//思路:
		//1. 将赫夫曼编码表存放在 Map<Byte,String> 形式
		//   生成的赫夫曼编码表{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
		static Map<Byte, String> huffmanCodes = new HashMap<Byte,String>();
		//2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
		static StringBuilder stringBuilder = new StringBuilder();	
		//为了调用方便,重载 getCodes
		private static Map<Byte, String> getCodes(Node root) {
			if(root == null) {
				return null;
			}
			//处理root的左子树
			getCodes(root.left, "0", stringBuilder);
			//处理root的右子树
			getCodes(root.right, "1", stringBuilder);
			return huffmanCodes;
		}
		
		/**
		 * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合
		 * @param node  传入结点
		 * @param code  路径： 左子结点是 0, 右子结点 1
		 * @param stringBuilder 用于拼接路径
		 */
		private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
			StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
			//将code 加入到 stringBuilder2
			stringBuilder2.append(code);
			if(node != null) { //如果node == null不处理
				//判断当前node 是叶子结点还是非叶子结点
				if(node.data == null) { //非叶子结点
					//递归处理
					//向左递归
					getCodes(node.left, "0", stringBuilder2);
					//向右递归
					getCodes(node.right, "1", stringBuilder2);
				} else { //说明是一个叶子结点
					//就表示找到某个叶子结点的最后
					huffmanCodes.put(node.data, stringBuilder2.toString());
				}
			}
		}
		
	//前序遍历的方法
	private static void preOrder(Node root) {
		if(root != null) {
			root.preOrder();
		}else {
			System.out.println("赫夫曼树为空");
		}
	}
	
	/**
	 * 
	 * @param bytes 接收字节数组
	 * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......],
	 */
	private static List<Node> getNodes(byte[] bytes) {		
		//1创建一个ArrayList
		ArrayList<Node> nodes = new ArrayList<Node>();
		
		//遍历 bytes , 统计 每一个byte出现的次数->map[key,value]
		Map<Byte, Integer> counts = new HashMap<>();
		for (byte b : bytes) {
			Integer count = counts.get(b);
			if (count == null) { // Map还没有这个字符数据,第一次
				counts.put(b, 1);
			} else {
				counts.put(b, count + 1);
			}
		}		
		//把每一个键值对转成一个Node 对象，并加入到nodes集合
		//遍历map
		for(Map.Entry<Byte, Integer> entry: counts.entrySet()) {
			nodes.add(new Node(entry.getKey(), entry.getValue()));
		}
		return nodes;		
	}		
	//可以通过List 创建对应的赫夫曼树
	private static Node createHuffmanTree(List<Node> nodes) {		
		while(nodes.size() > 1) {
			//排序, 从小到大
			Collections.sort(nodes);
			//取出第一颗最小的二叉树
			Node leftNode = nodes.get(0);
			//取出第二颗最小的二叉树
			Node rightNode = nodes.get(1);
			//创建一颗新的二叉树,它的根节点 没有data, 只有权值
			Node parent = new Node(null, leftNode.weight + rightNode.weight);
			parent.left = leftNode;
			parent.right = rightNode;
			
			//将已经处理的两颗二叉树从nodes删除
			nodes.remove(leftNode);
			nodes.remove(rightNode);
			//将新的二叉树，加入到nodes
			nodes.add(parent);
			
		}
		//nodes 最后的结点，就是赫夫曼树的根结点
		return nodes.get(0);		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300

40
nodes=[Node [data = 32 weight=9], Node [data = 97 weight=5], Node [data = 100 weight=1], Node [data = 101 weight=4], Node [data = 117 weight=1], Node [data = 118 weight=2], Node [data = 105 weight=5], Node [data = 121 weight=1], Node [data = 106 weight=2], Node [data = 107 weight=4], Node [data = 108 weight=4], Node [data = 111 weight=2]]
哈夫曼树
前序遍历
Node [data = null weight=40]
Node [data = null weight=17]
Node [data = null weight=8]
Node [data = 108 weight=4]
Node [data = null weight=4]
Node [data = 106 weight=2]
Node [data = 111 weight=2]
Node [data = 32 weight=9]
Node [data = null weight=23]
Node [data = null weight=10]
Node [data = 97 weight=5]
Node [data = 105 weight=5]
Node [data = null weight=13]
Node [data = null weight=5]
Node [data = null weight=2]
Node [data = 100 weight=1]
Node [data = 117 weight=1]
Node [data = null weight=3]
Node [data = 121 weight=1]
Node [data = 118 weight=2]
Node [data = null weight=8]
Node [data = 101 weight=4]
Node [data = 107 weight=4]
~生成的哈夫曼编码表:
{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
i like like like java do you like a java
字符串对应的哈夫曼编码：1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100
huffmanCodeBytes=[-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
将压缩后的Byte数组解压为原字符串：
原来的字符串=i like like like java do you like a java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

文件压缩：读取文件——>得到哈夫曼编码表——>进行压缩
文件解压：读取压缩文件——>根据哈夫曼编码表——>完成解压

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HuffmanCode {
	public static void main(String[] args) {	
		//测试压缩文件
		String srcFile = "C://Users//zhukun//Desktop//测试//01.docx";
	    String dstFile = "C://Users//zhukun//Desktop//测试//01.zip";		
		zipFile(srcFile, dstFile);
		System.out.println("压缩文件ok~~");	
		
//		//测试解压文件
//		String zipFile = "C://Users//zhukun//Desktop//01.zip";
//		String dstFile = "C://Users//zhukun//Desktop//02.docx";
//		unZipFile(zipFile, dstFile);
//		System.out.println("解压成功!");
	
	}
	//编写一个方法，完成对压缩文件的解压
	/**
	 * 
	 * @param zipFile 准备解压的文件
	 * @param dstFile 将文件解压到哪个路径
	 */
	public static void unZipFile(String zipFile, String dstFile) {	
		//定义文件输入流
		InputStream is = null;
		//定义一个对象输入流
		ObjectInputStream ois = null;
		//定义文件的输出流
		OutputStream os = null;
		try {
			//创建文件输入流
			is = new FileInputStream(zipFile);
			//创建一个和  is关联的对象输入流
			ois = new ObjectInputStream(is);
			//读取byte数组  huffmanBytes
			byte[] huffmanBytes = (byte[])ois.readObject();
			//读取赫夫曼编码表
			Map<Byte,String> huffmanCodes = (Map<Byte,String>)ois.readObject();
			
			//解码
			byte[] bytes = decode(huffmanCodes, huffmanBytes);
			//将bytes 数组写入到目标文件
			os = new FileOutputStream(dstFile);
			//写数据到 dstFile 文件
			os.write(bytes);
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		} finally {
			
			try {
				os.close();
				ois.close();
				is.close();
			} catch (Exception e2) {
				// TODO: handle exception
				System.out.println(e2.getMessage());
			}
			
		}
	}
	
	//编写方法，将一个文件进行压缩
	/**
	 * 
	 * @param srcFile 你传入的希望压缩的文件的全路径
	 * @param dstFile 我们压缩后将压缩文件放到哪个目录
	 */
	public static void zipFile(String srcFile, String dstFile) {
		
		//创建输出流
		OutputStream os = null;
		ObjectOutputStream oos = null;
		//创建文件的输入流
		FileInputStream is = null;
		try {
			//创建文件的输入流
			is = new FileInputStream(srcFile);
			//创建一个和源文件大小一样的byte[]
			byte[] b = new byte[is.available()];
			//读取文件
			is.read(b);
			//直接对源文件压缩
			byte[] huffmanBytes = huffmanZip(b);
			//创建文件的输出流, 存放压缩文件
			os = new FileOutputStream(dstFile);
			//创建一个和文件输出流关联的ObjectOutputStream
			oos = new ObjectOutputStream(os);
			//把 赫夫曼编码后的字节数组写入压缩文件
			oos.writeObject(huffmanBytes); //我们是把
			//这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用
			//注意一定要把赫夫曼编码 写入压缩文件
			oos.writeObject(huffmanCodes);			
		}catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}finally {
			try {
				is.close();
				oos.close();
				os.close();
			}catch (Exception e) {
				// TODO: handle exception
				System.out.println(e.getMessage());
			}
		}	
	}
	//完成数据的解压
	//思路
	//1. 将huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
	//   重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."
	//2.  赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码  =》 "i like like like java do you like a java"
	//编写一个方法，完成对压缩数据的解码
	/**
	 * 
	 * @param huffmanCodes 赫夫曼编码表 map
	 * @param huffmanBytes 赫夫曼编码得到的字节数组
	 * @return 就是原来的字符串对应的数组
	 */
	private static byte[] decode(Map<Byte,String> huffmanCodes, byte[] huffmanBytes) {
		//1. 先得到 huffmanBytes 对应的 二进制的字符串 ， 形式 1010100010111...
		StringBuilder stringBuilder = new StringBuilder();
		//将byte数组转成二进制的字符串
		for(int i = 0; i < huffmanBytes.length; i++) {
			byte b = huffmanBytes[i];
			//判断是不是最后一个字节
			boolean flag = (i == huffmanBytes.length - 1);
			stringBuilder.append(byteToBitString(!flag, b));
		}
		//把字符串安装指定的赫夫曼编码进行解码
		//把赫夫曼编码表进行调换，因为反向查询 a->100 100->a
		Map<String, Byte>  map = new HashMap<String,Byte>();
		for(Map.Entry<Byte, String> entry: huffmanCodes.entrySet()) {
			map.put(entry.getValue(), entry.getKey());
		}
		
		//创建要给集合，存放byte
		List<Byte> list = new ArrayList<>();
		//i 可以理解成就是索引,扫描 stringBuilder 
		for(int  i = 0; i < stringBuilder.length(); ) {
			int count = 1; // 小的计数器
			boolean flag = true;
			Byte b = null;
			
			while(flag) {
				//1010100010111...
				//递增的取出 key 1 
				String key = stringBuilder.substring(i, i+count);//i 不动，让count移动，指定匹配到一个字符
				b = map.get(key);
				if(b == null) {//说明没有匹配到
					count++;
				}else {
					//匹配到
					flag = false;
				}
			}
			list.add(b);
			i += count;//i 直接移动到 count	
		}
		//当for循环结束后，我们list中就存放了所有的字符  "i like like like java do you like a java"
		//把list 中的数据放入到byte[] 并返回
		byte b[] = new byte[list.size()];
		for(int i = 0;i < b.length; i++) {
			b[i] = list.get(i);
		}
		return b;
		
	}
 	
	/**
	 * 将一个byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的Java基础 二进制的原码，反码，补码
	 * @param b 传入的 byte
	 * @param flag 标志是否需要补高位如果是true ，表示需要补高位，如果是false表示不补, 如果是最后一个字节，无需补高位
	 * @return 是该b 对应的二进制的字符串，（注意是按补码返回）
	 */
	private static String byteToBitString(boolean flag, byte b) {
		//使用变量保存 b
		int temp = b; //将 b 转成 int
		//如果是正数我们还存在补高位
		if(flag) {
			temp |= 256; //按位与 256  1 0000 0000  | 0000 0001 => 1 0000 0001
		}
		String str = Integer.toBinaryString(temp); //返回的是temp对应的二进制的补码
		if(flag) {
			return str.substring(str.length() - 8);
		} else {
			return str;
		}
	}
	
	//使用一个方法，将前面的方法封装起来，便于我们的调用.
	/**
	 * 
	 * @param bytes 原始的字符串对应的字节数组
	 * @return 是经过 赫夫曼编码处理后的字节数组(压缩后的数组)
	 */
	private static byte[] huffmanZip(byte[] bytes) {
		List<Node> nodes = getNodes(bytes);
		//根据 nodes 创建的赫夫曼树
		Node huffmanTreeRoot = createHuffmanTree(nodes);
		//对应的赫夫曼编码(根据 赫夫曼树)
		Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
		//根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
		byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
		return huffmanCodeBytes;
	}
	
	
	//编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
	/**
	 * 
	 * @param bytes 这时原始的字符串对应的 byte[]
	 * @param huffmanCodes 生成的赫夫曼编码map
	 * @return 返回赫夫曼编码处理后的 byte[] 
	 * 举例： String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes();
	 * 返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
	 * => 对应的 byte[] huffmanCodeBytes  ，即 8位对应一个 byte,放入到 huffmanCodeBytes
	 * huffmanCodeBytes[0] =  10101000(补码) => byte  [推导  10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ]
	 * huffmanCodeBytes[1] = -88
	 */
	private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
		
		//1.利用 huffmanCodes 将  bytes 转成  赫夫曼编码对应的字符串
		StringBuilder stringBuilder = new StringBuilder();
		//遍历bytes 数组 
		for(byte b: bytes) {
			stringBuilder.append(huffmanCodes.get(b));
		}
		
		//System.out.println("测试 stringBuilder~~~=" + stringBuilder.toString());
		
		//将 "1010100010111111110..." 转成 byte[]
		
		//统计返回  byte[] huffmanCodeBytes 长度
		//一句话 int len = (stringBuilder.length() + 7) / 8;
		int len;
		if(stringBuilder.length() % 8 == 0) {
			len = stringBuilder.length() / 8;
		} else {
			len = stringBuilder.length() / 8 + 1;
		}
		//创建 存储压缩后的 byte数组
		byte[] huffmanCodeBytes = new byte[len];
		int index = 0;//记录是第几个byte
		for (int i = 0; i < stringBuilder.length(); i += 8) { //因为是每8位对应一个byte,所以步长 +8
				String strByte;
				if(i+8 > stringBuilder.length()) {//不够8位
					strByte = stringBuilder.substring(i);
				}else{
					strByte = stringBuilder.substring(i, i + 8);
				}	
				//将strByte 转成一个byte,放入到 huffmanCodeBytes
				huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte, 2);
				index++;
		}
		return huffmanCodeBytes;
	}
	
	//生成赫夫曼树对应的赫夫曼编码
	//思路:
	//1. 将赫夫曼编码表存放在 Map<Byte,String> 形式
	//   生成的赫夫曼编码表{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
	static Map<Byte, String> huffmanCodes = new HashMap<Byte,String>();
	//2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
	static StringBuilder stringBuilder = new StringBuilder();
	
	
	//为了调用方便，我们重载 getCodes
	private static Map<Byte, String> getCodes(Node root) {
		if(root == null) {
			return null;
		}
		//处理root的左子树
		getCodes(root.left, "0", stringBuilder);
		//处理root的右子树
		getCodes(root.right, "1", stringBuilder);
		return huffmanCodes;
	}
	
	/**
	 * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合
	 * @param node  传入结点
	 * @param code  路径： 左子结点是 0, 右子结点 1
	 * @param stringBuilder 用于拼接路径
	 */
	private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
		StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
		//将code 加入到 stringBuilder2
		stringBuilder2.append(code);
		if(node != null) { //如果node == null不处理
			//判断当前node 是叶子结点还是非叶子结点
			if(node.data == null) { //非叶子结点
				//递归处理
				//向左递归
				getCodes(node.left, "0", stringBuilder2);
				//向右递归
				getCodes(node.right, "1", stringBuilder2);
			} else { //说明是一个叶子结点
				//就表示找到某个叶子结点的最后
				huffmanCodes.put(node.data, stringBuilder2.toString());
			}
		}
	}
	
	//前序遍历的方法
	private static void preOrder(Node root) {
		if(root != null) {
			root.preOrder();
		}else {
			System.out.println("赫夫曼树为空");
		}
	}
	
	/**
	 * 
	 * @param bytes 接收字节数组
	 * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......],
	 */
	private static List<Node> getNodes(byte[] bytes) {
		//1创建一个ArrayList
		ArrayList<Node> nodes = new ArrayList<Node>();	
		//遍历 bytes , 统计 每一个byte出现的次数->map[key,value]
		Map<Byte, Integer> counts = new HashMap<>();
		for (byte b : bytes) {
			Integer count = counts.get(b);
			if (count == null) { // Map还没有这个字符数据,第一次
				counts.put(b, 1);
			} else {
				counts.put(b, count + 1);
			}
		}		
		//把每一个键值对转成一个Node 对象，并加入到nodes集合
		//遍历map
		for(Map.Entry<Byte, Integer> entry: counts.entrySet()) {
			nodes.add(new Node(entry.getKey(), entry.getValue()));
		}
		return nodes;
		
	}
	//可以通过List 创建对应的赫夫曼树
	private static Node createHuffmanTree(List<Node> nodes) {
		while(nodes.size() > 1) {
			//排序, 从小到大
			Collections.sort(nodes);
			//取出第一颗最小的二叉树
			Node leftNode = nodes.get(0);
			//取出第二颗最小的二叉树
			Node rightNode = nodes.get(1);
			//创建一颗新的二叉树,它的根节点 没有data, 只有权值
			Node parent = new Node(null, leftNode.weight + rightNode.weight);
			parent.left = leftNode;
			parent.right = rightNode;	
			//将已经处理的两颗二叉树从nodes删除
			nodes.remove(leftNode);
			nodes.remove(rightNode);
			//将新的二叉树，加入到nodes
			nodes.add(parent);		
		}
		//nodes 最后的结点，就是赫夫曼树的根结点
		return nodes.get(0);	
	}
}

//创建Node ,待数据和权值
class Node implements Comparable<Node>  {
	Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
	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 this.weight - o.weight;
	}
	public String toString() {
		return "Node [data = " + data + " weight=" + weight + "]";
	}	
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404