java代碼創建HuffmanTree

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * 創建HuffmanTree
 * 
 * @author LYYL
 *
 */
public class HuffmanTree {
	private static class Node{
		E data;
		double weight;
		Node leftChild;
		Node rightChild;
		public Node(E data, double weight){
			this.data = data;
			this.weight = weight;
		}
		public String toString(){
			return "Node[data="+data+", weight" + weight + "]";
		}
	}
	private Node createTree(List nodes){
		while(nodes.size() > 1){
			quickSort(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.leftChild = left;
			parent.rightChild = right;
			nodes.remove(nodes.size()-1);
			nodes.remove(nodes.size()-1);
			nodes.add(parent);
		}
		return nodes.get(0);
	}
	//將指定數組的i和j索引處的元素交換
	private void swap(List nodes, int i, int j){
		Node temp;
		temp = nodes.get(i);
		nodes.set(i, nodes.get(j));
		nodes.set(j, temp);
	}
	//用快速排序法實現對節點進行排序
	private void subSort(List nodes, int start, int end){
		if(start < end){
			//以第一個元素最爲分界值
			Node base = nodes.get(start);
			//i從左邊搜索，搜索大於分界值的元素索引
			int i = start;
			//j從右邊搜索，搜索小於分界值的索引
			int j = end + 1;
			while(true){
				while(i < end && nodes.get(++i).weight >= base.weight);
				while(j > start && nodes.get(--j).weight <=base.weight);
				if(i < j){
					swap(nodes, i, j);
				}else{
					break;
				}
			}
			swap(nodes, start, j);
			subSort(nodes, start, j-1);
			subSort(nodes, j+1, end);
		}
	}
	//快速排序節點
	private void quickSort(List nodes){
		subSort(nodes, 0, nodes.size()-1);
	}
	//廣度優先遍歷
	private 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());
			Node p = queue.poll();
			System.out.println(p.leftChild);
			if(p.leftChild != null){
				queue.offer(p.leftChild);
			}
			if(p.rightChild != null){
				queue.offer(p.rightChild);
			}
		}
		return list;
	}
	public static void main(String[] args) {
		List nodes = new ArrayList();
		nodes.add(new Node("A", 40.0));
		nodes.add(new Node("B", 8.0));
		nodes.add(new Node("C", 10.0));
		nodes.add(new Node("D", 30.0));
		nodes.add(new Node("E", 10.0));
		nodes.add(new Node("F", 20.0));
		nodes.add(new Node("G", 3.0));
		HuffmanTree huffmanTree = new HuffmanTree();
		Node root = huffmanTree.createTree(nodes);
		System.out.println(huffmanTree.breadthFirst(root));
	}
}

創建HuffmanTree中的關鍵思想：

1、對List集合中所有節點進行排序

2、找出List集合中權值最小的兩個節點

3、以權值最小的兩個節點作爲子節點創建新節點

4、從List集合中刪除權值最小的最小的兩個節點，將新節點添加到List集合中

程序採用循環不斷地執行上面1、2、3、4步，直到List集合中只剩下一個節點，最後剩下的這個節點就是哈夫曼樹的根節點。