HuffmanTree java

import java.util.*;


/**
 * Description: 
 *   給定n個權值做爲n個葉子結點，
 *   構造一棵二叉樹，若帶權路徑長度達到最小，
 *   稱這樣的二叉樹爲最優二叉樹，也稱爲哈夫曼樹(Huffman tree)
 *  
 * 
 *  
 */


public class HuffmanTree
{
public static class Node<E>
{
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 + "]";
}
}
public static void main(String[] args)
{
List<Node> nodes = new ArrayList<Node>();
nodes.add(new Node("A" ,25.0));
nodes.add(new Node("B" , 8.0));
nodes.add(new Node("C" , 15.0));
nodes.add(new Node("D" , 30.0));
nodes.add(new Node("E" , 10.0));
nodes.add(new Node("F" , 2.0));
Node root = HuffmanTree.createTree(nodes);
System.out.println(breadthFirst(root));
}
/**

* 構造哈夫曼樹                                                                                                                        假設有n個權值，則構造出的哈夫曼樹有n個葉子結點。 n個權值分別設爲 w一、w二、…、wn，則哈夫曼樹的構造規則爲：

*     (1) 將w一、w二、…，wn當作是有n 棵樹的森林(每棵樹僅有一個結點)；

*     (2) 在森林中選出兩個根結點的權值最小的樹合併，做爲一棵新樹的左、右子樹，且新樹的根結點權值爲其左、右子樹根結點權值之和；

*     (3)從森林中刪除選取的兩棵樹，並將新樹加入森林；

*  (4)重複(2)、(3)步，直到森林中只剩一棵樹爲止，該樹即爲所求得的哈夫曼樹。                                * @param nodes 節點集合                                                                                                        * @return 構造出來的哈夫曼樹的根節點 

           */

private static Node createTree(List<Node> nodes)

{ //只要nodes數組中還有2個以上的節點 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); } //返回nodes集合中惟一的節點，也就是根節點 return nodes.get(0); } //將指定數組的i和j索引處的元素交換 private static void swap(List<Node> nodes, int i, int j) { Node tmp; tmp = nodes.get(i); nodes.set(i , nodes.get(j)); nodes.set(j , tmp); } //實現快速排序算法，用於對節點進行排序 private static void subSort(List<Node> nodes , int start , int end) { //須要排序 if (start < end) { //以第一個元素做爲分界值 Node base = nodes.get(start); //i從左邊搜索，搜索大於分界值的元素的索引 int i = start; //j從右邊開始搜索，搜索小於分界值的元素的索引 int j = end + 1; while(true) { //找到大於分界值的元素的索引，或i已經到了end處 while(i < end && nodes.get(++i).weight >= base.weight); //找到小於分界值的元素的索引，或j已經到了start處 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); } } public static void quickSort(List<Node> nodes)  { subSort(nodes , 0 , nodes.size() - 1); } //廣度優先遍歷 public static List<Node> breadthFirst(Node root) { Queue<Node> queue = new ArrayDeque<Node>(); List<Node> list = new ArrayList<Node>(); if( root != null) { //將根元素入「隊列」 queue.offer(root); } while(!queue.isEmpty()) { //將該隊列的「隊尾」的元素添加到List中 list.add(queue.peek()); Node p = queue.poll(); //若是左子節點不爲null，將它加入「隊列」 if(p.leftChild != null) { queue.offer(p.leftChild); } //若是右子節點不爲null，將它加入「隊列」 if(p.rightChild != null) { queue.offer(p.rightChild); } } return list; } }