JAVA实现赫夫曼树编码

赫夫曼(Huffman)树，又称最优树，是一类带权路径长度长度最短的树。

赫夫曼树，最优二叉树，从树的一个结点到另一个结点之间的分支构成这两个结点之间的路径，路径上的分支数目称路径长度。树的路径长度是从树根到每一个结点的路径长度纸盒。结点的带权路径长度为从该结点到树根之间的路径长度与结点上的权的乘积。

树的带权路径长度为树中所有叶子结点的带权路径长度之和WPL = (W1*L1+W2*L2+W3*L3+...+Wn*Ln)

构造赫夫曼树的算法：

1.根据给定的n个权值{w1,w2,...,wn}构成n棵二叉树的集合F={T1,T2,...,Tn},其中每棵二叉树Ti中只有一个带权为wi的根节点，其左右子树为空。

2.在F中选取两棵根结点的权值最小的树作为左右子树构成一棵新的二叉树，且置新的二叉树的根结点的权值为左、右子树上根结点的权值之和。

3.在F中删除这两棵树，同时将新得到的二叉树加入F中。

4.重复2和3，直到F只含有一棵树为止。这棵树便是赫夫曼树。

下面给出赫夫曼树的Java实现：

结点类：

package com.lintcode.example;

import java.util.LinkedList;

public class HuffmanTree {

	public static void main(String[] args) {
		TreeNode root = new TreeNode(1);
		TreeNode r1 = new TreeNode(5);
		TreeNode r2 = new TreeNode(10);
		TreeNode r3 = new TreeNode(0);
		
		r1.left = r2;
		root.left = r1;
		root.right = r3;
		
		System.out.println("原始树的先序遍历结果:");
		pretraverseR(root);
		System.out.println();
		TreeNode huffRoot = BinaryHuffmanTree(root);
		System.out.println("赫夫曼的先序遍历结果:");
		pretraverseR(huffRoot);
		
		
	}
	
	public static class TreeNode{
		int value;
		TreeNode left;
		TreeNode right;
		
		public TreeNode(int value) {
			this.value = value;
			this.left = this.right = null;
		}
		
		public int getValue() {
			return value;
		}
		public void setValue(int value) {
			this.value = value;
		}
		public TreeNode getLeft() {
			return left;
		}
		public void setLeft(TreeNode left) {
			this.left = left;
		}
		public TreeNode getRight() {
			return right;
		}

		public void setRight(TreeNode right) {
			this.right = right;
		}

	}
	
	//先序遍历(用于打印测试结点)
	public static void pretraverseR(TreeNode root){
		if(root == null)return;
		System.out.print(root.getValue()+" ");
		if(root.left != null)pretraverseR(root.left);
		if(root.right != null)pretraverseR(root.right);
	}
	
	//采用先序遍历将结点存入LinkedList中
	public static LinkedList<TreeNode> treeToList(TreeNode node, LinkedList<TreeNode> list){
		if(node == null)return list;
		list.add(node);
		if(node.left != null)
		{
			treeToList(node.left,list);
		}
		if(node.right != null)
		{
			treeToList(node.right,list);
		}
		return list;
	}
	
	/**
	 * 将一个树转换为赫夫曼树
	 * @param node 该节点为一个树的根节点
	 * @return 赫夫曼树的根节点
	 */
	public static TreeNode BinaryHuffmanTree(TreeNode root){
		//首先需要遍历树，将树的每一个节点存入一个LinkedList集合中
		LinkedList<TreeNode> list = new LinkedList<TreeNode>();
		list = treeToList(root, list);
		
		return buildHuffmanTree(list);
	}

	/**
	 * 依据list中每一个结点构造赫夫曼树
	 * @param list
	 * @return 赫夫曼树的根节点
	 */
	private static TreeNode buildHuffmanTree(LinkedList<TreeNode> list) {
		//1.首先需要将list中每一个结点的左右子树变为空
		for(TreeNode node : list)
		{
			if(node.left != null)
			{
				//将该节点的左结点置为空
				node.setLeft(null);
			}
			if(node.right != null)
			{
				node.setRight(null);
			}
		}
		
		//2.进行循环构造
		while(list.size() > 1)
		{
			//最小值(作为右节点)
			int min1 = findMinNode(list);
			TreeNode rightNode = list.remove(min1);
			
			//次小值(作为左结点)
			int min2 = findMinNode(list);
			TreeNode leftNode = list.remove(min2);
			
			//同时生成这两个结点的父节点
			TreeNode parent = new TreeNode(rightNode.getValue()+leftNode.getValue());
			parent.setLeft(leftNode);
			parent.setRight(rightNode);
			list.add(parent);
		}
		return list.get(0);
	}

	/**
	 * 找出list集合中最小的值
	 * @param list
	 * @return 最小值在list中的位置
	 */
	private static int findMinNode(LinkedList<TreeNode> list) {
		int min = list.get(0).getValue();
		int index = 0;
		for(int i=0;i<list.size();i++)
		{
			if(list.get(i).getValue() < min)
			{
				min = list.get(i).getValue();
				index = i;
			}
		}
		return index;
	}
}