大话数据结构十六：哈夫曼树(最优二叉树)

1. 引子

当前素质教育的背景下，小学的学科成绩都改为了优秀、良好、及格、不及格这样的模糊词语，而不再通报具体的分数。

用代码可以表示如下：

 if( a < 60 )
		System.out.print("不及格");
	else if( a < 70 )
		System.out.print("及格");
	else if( a < 90 )
		System.out.print("良好");
	else
		System.out.print("优秀");

粗略看这样做是没问题的，但是一张好的试卷大部分学生成绩集中在"良好"，而上面的程序需要判断两次才能到"良好"，输入量很大的时候，在算法效率上其实是有问题的。所以应该做如下改进（① -> ②）：

2. 哈夫曼树定义和原理

我们先把上图简化成叶子结点带权的二叉树（注：树结点间的连线相关的数叫做权，Weight）。

① 结点的路径长度：从根结点到该结点的路径上的连接数。

② 树的路径长度：树中每个叶子结点的路径长度之和。

③ 结点带权路径长度：结点的路径长度与结点权值的乘积。

④ 树的带权路径长度：WPL(Weighted Path Length)是树中所有叶子结点的带权路径长度之和。

※WPL的值越小，说明构造出来的二叉树性能越优，这种最优二叉树又称为哈夫曼树。

3. 哈夫曼树的存储结构：

weight

data

leftChild

rightChild

哈夫曼树的结点存储结构为双亲孩子存储结构：

① weight： 结点的权值。

② data：结点的值。

③ leftChild：结点的左孩子。

④ rightChild：结点的右孩子。

4. 构造哈夫曼树：

对于已知的一组叶子的权值Ｗ 1 ，Ｗ 2...... ，Ｗ n
① 首先把 n 个叶子结点看做 n 棵树（仅有一个结点的二叉树），n棵树组成一个森林。
② 把森林中权值最小和次小的两棵树合并成一棵树(小的放左边，大的放右边)，该树根结点的权值是两棵子树权值之和，这时森林中还有 n-1 棵树。
③ 重复第②步直到森林中只有一棵为止。此树就是哈夫曼树。

现给一组 (n=4) 具体的权值 2 、4 、5 、 8 ，下边是构造具体过程：

5. Java实现哈夫曼树

import java.util.*;

public class HuffmanTree { 

	/*
	 * 结点内部类
	 */
	public static class Node {
		private String data; // 结点值
		private int weight; // 权值
		private Node leftChild; // 左孩子
		private Node rightChild; // 右孩子

		public Node(String data, int weight) {
			this.data = data;
			this.weight = weight;
		}

		public String toString() {
			return "Node[data=" + data + ", weight=" + weight + "]";
		}
	}

	/**
	 * 构造哈夫曼树
	 * 
	 * @param nodes节点集合
	 * @return 构造出来的哈夫曼树的根节点
	 */
	private static Node buildHaffmanTree(List nodesList) {
		while (nodesList.size() > 1) { // 只要nodes数组中还有2个以上的节点
			quickSort(nodesList, 0, nodesList.size() - 1);
			Node left = nodesList.get(nodesList.size() - 1); // 获取权值最小的两个节点
			Node right = nodesList.get(nodesList.size() - 2);
			Node parent = new Node(null, left.weight + right.weight); // 生成新节点，新节点的权值为两个子节点的权值之和
			parent.leftChild = left; // 让新节点作为权值最小的两个节点的父节点
			parent.rightChild = right;
			nodesList.remove(nodesList.size() - 1); // 删除权值最小的两个节点
			nodesList.remove(nodesList.size() - 1);
			nodesList.add(parent); // 将新生成的父节点添加到集合中
		}
		return nodesList.get(0); // 返回nodes集合中唯一的节点，也就是根节点
	}

	/**
	 * 实现快速排序算法，用于对节点进行排序
	 * 
	 * @param nodesList
	 * @param start
	 * @param end
	 */
	private static void quickSort(List nodesList, int start, int end) {
		if (start < end) { // 需要排序
			Node base = nodesList.get(start); // 以第一个元素作为分界值
			int i = start; // i从左边搜索，搜索大于分界值的元素的索引
			int j = end + 1; // j从右边开始搜索，搜索小于分界值的元素的索引
			while (true) {
				while (i < end && nodesList.get(++i).weight >= base.weight){  // 找到大于分界值的元素的索引，或i已经到了end处
					;
				}
				while (j > start && nodesList.get(--j).weight <= base.weight){ // 找到小于分界值的元素的索引，或j已经到了start处
					;
				}
				if (i < j) {
					swap(nodesList, i, j);
				} else {
					break;
				}
			}
			swap(nodesList, start, j);
			quickSort(nodesList, start, j - 1); // 递归左子序列
			quickSort(nodesList, j + 1, end); // 递归右边子序列
		}
	}

	/**
	 * 将指定数组的i和j索引处的元素交换
	 * 
	 * @param nodesList
	 * @param i
	 * @param j
	 */
	private static void swap(List nodesList, int i, int j) {
		Node temp;
		temp = nodesList.get(i);
		nodesList.set(i, nodesList.get(j));
		nodesList.set(j, temp);
	}

	/**
	 * 广度优先遍历
	 * 
	 * @param root
	 * @return
	 */
	public static List breadthFirst(Node root) { 
		Queue queue = new ArrayDeque();
		List list = new ArrayList();
		if (root != null) {
			queue.offer(root); // 将根元素入"队列"
		}
		while (!queue.isEmpty()) {
			list.add(queue.peek()); // 将该队列的"队尾"的元素添加到List中
			Node p = queue.poll();
			if (p.leftChild != null) { // 如果左子节点不为null，将它加入"队列"
				queue.offer(p.leftChild);
			}
			if (p.rightChild != null) { // 如果右子节点不为null，将它加入"队列"
				queue.offer(p.rightChild);
			}
		}
		return list;
	}

	/**
	 * 测试方法
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		List nodesList = new ArrayList(); 
		nodesList.add(new Node("A", 2));
		nodesList.add(new Node("B", 4));
		nodesList.add(new Node("C", 5));
		nodesList.add(new Node("D", 8));
		Node root = HuffmanTree.buildHaffmanTree(nodesList);
		System.out.println(breadthFirst(root));
	}
}