用链式结构来建立哈夫曼树。

总体思路是：

将每一棵树（这是每一棵树只有一个节点，头节点）放在一个优先队列中（下面的是链表实现的优先队列），频率（rate）小的在队列头，取出队列头两个，频率相加之后组合成一个有三个节点的树，重新放入优先队列中。重复上面的过程，直到最后只剩下一个，则这最后一个便是哈夫曼树。

编码：从叶子节点开始往上。

解码：从根节点开始往下。

package tree;

import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;import java.util.Stack;

/** * 哈夫曼编码解码 * @author LiangYH * */public class HuffmanTest {

   public static void main(String[] args) {      HuffmanTest tree1 = new HuffmanTest();       tree1.setRoot("A", 9);

      HuffmanTest tree2 = new HuffmanTest();       tree2.setRoot("B", 5);

      HuffmanTest tree3 = new HuffmanTest();       tree3.setRoot("C", 8);      HuffmanTest tree4 = new HuffmanTest();       tree4.setRoot("E", 19);     HuffmanTest tree7 = new HuffmanTest();       tree7.setRoot("F", 11);

      MyLink link = new MyLink();      link.add(tree1);      link.add(tree2);      link.add(tree3);      link.add(tree7);      link.add(tree4);      link.printLink();

      HuffmanTest t1 = null;       HuffmanTest t2 = null;       while(link.size() > 1){            t1 = link.delete();          t2 = link.delete();          t2.growTree(t1);          link.add(t2);     }

      t2.printTree();

      Map<String,List<String>> map = t2.getCodeTable();

      t2.printCodeTable(map);

      List<String> list = t2.encode("AEBCF");

      List<String> li2 = t2.decode(list);

      System.out.println();     System.out.print("解码： ");        for(String s: li2){           System.out.print(s);      } }

  private List<Node> leaves = null;  private Map<String, List<String>> codeMap= null;

  private Node root = null;

  public HuffmanTest(){     leaves = new ArrayList<Node>();        codeMap = new HashMap<String, List<String>>();   }

  public Map<String,List<String>> getCodeMap(){     return this.codeMap;  }

  public List<Node> getLeaves(){      getLeaves(root);      return this.leaves;   }

  public void setRoot(String item, int rate){       this.root = new Node(item, rate);    }

  public Node getRoot(){        return this.root; }

  public int getRateOfRoot(){       return this.root.rate;    }

  public void growTree(HuffmanTest newTree){        Node newNode = new Node();       //设置子节点       newNode.leftChild = this.root;       newNode.rightChild = newTree.getRoot();      //设置父节点       this.root.parent = newNode;      newTree.getRoot().parent = newNode;      //设置父节点的权重        newNode.setRate(this.root.rate+newTree.getRateOfRoot());     //重置根节点       this.root = newNode; }

  public void InOrderTraverse(HuffmanTest tree){        traverse(tree.root);

  }

  private void traverse(Node node){     if(node != null){            System.out.print(node.item+"/"+node.rate+"; ");            traverse(node.leftChild);         traverse(node.rightChild);        } }

  //获取叶子节点  private void getLeaves(Node node){        if(node != null){            if(node.item != null){               leaves.add(node);         }         getLeaves(node.leftChild);

          getLeaves(node.rightChild);       } }

   public Map<String,List<String>> getCodeTable(){       //获取叶子节点      getLeaves(root);      int len = leaves.size();     for(int i = 0; i < len; i++){           Node tempNode = leaves.get(i);           List<String> tempList = new ArrayList<String>();

          codeMap.put(tempNode.item, tempList);

          while(tempNode.parent != null){              if(tempNode == tempNode.parent.leftChild){                  tempList.add("0");              }else if(tempNode == tempNode.parent.rightChild){                   tempList.add("1");              }             tempNode = tempNode.parent;          }     }

      return this.codeMap;  }

  public List<String> encode(String target){      System.out.println();     System.out.print(target+" 的编码: ");

      List<String> li = new ArrayList<String>();

      int len = target.length();       for(int i = 0; i < len; i++){           String temp = String.valueOf(target.charAt(i));          List<String> list = codeMap.get(temp);         for(int k = list.size()-1; k >= 0; k--){             System.out.print(list.get(k));                li.add(list.get(k));          }     }     return li;    }

  /**    * 解码  * @param codeList 二进制编码  * @return 解码结果   */   public List<String> decode(List<String> codeList){

      List<String> list = new ArrayList<String>();

      Node tempNode = null;        tempNode = root;     for(String s: codeList){          if("0".equals(s)){              tempNode = tempNode.leftChild;               if(tempNode.item != null){                   list.add(tempNode.item);                  tempNode = root;                 continue;             }         }else if("1".equals(s)){                tempNode = tempNode.rightChild;              if(tempNode.item != null){                   list.add(tempNode.item);                  tempNode = root;                 continue;             }         }     }     return list;  }

  public void printTree(){      InOrderTraverse(this);    }

  public void printCodeTable(Map<String,List<String>> codeTable){       Set<Entry<String,List<String>>> set = codeTable.entrySet();        Iterator<Entry<String,List<String>>> iter = set.iterator();        System.out.println();     while(iter.hasNext()){            Entry<String,List<String>> entry = iter.next();          System.out.print(entry.getKey()+": ");

          List<String> li = entry.getValue();            for(int i = li.size()-1; i >= 0; i--){               System.out.print(li.get(i));

          }         System.out.print("; ");     } }

  class Node{       Node leftChild = null;       Node rightChild = null;      Node parent = null;      //字母      String item = null;      //字母出现的频率     int rate = 0;

      public Node(){

      }     public Node(String item, int rate){           this.item = item;            this.rate = rate;        }

      public void setItem(String item){         this.item = item;        }

      public void setRate(int rate){            this.rate = rate;        }

      public void printNode(){          System.out.println(item+"\\"+rate+"; ");       } }}

/** * 优先链表 * @author LiangYH * */class MyLink{

  private LinkNode first = null;   private int size = 0;

  public MyLink(){

  }

  /**    * 增加节点，并按照相关顺序从小到大排列   * @param tree    */   public void add(HuffmanTest tree){        LinkNode newNode = new LinkNode(tree);

      if(first == null){          first = newNode;         size++;     }else{            boolean isNextNull = false;          LinkNode previous = first;           LinkNode temp = first;           while(tree.getRateOfRoot() > temp.tree.getRateOfRoot()){               if(temp.next == null){                  isNextNull = true;                   break;                }             previous = temp;             temp = temp.next;            }

          //temp所指的是最后一个            if(isNextNull){               temp.next = newNode;             size++;             return;           }         //如果temp指向的是第一个           if(temp == first){              newNode.next = first;                first = newNode;             size++;         }else{                newNode.next = temp;             previous.next = newNode;             size++;         }

      } }

  /**    * 删除最左边的一个元素  * @return    */   public HuffmanTest delete(){      if(isEmpty())         return null;

      LinkNode temp = first;       first = first.next;

      size--;       return temp.tree; }

  public boolean isEmpty(){     return first == null;   }

  public int size(){        return this.size; }

  public void printLink(){      LinkNode temp = first;       while(temp.next != null){            System.out.print(temp.tree.getRoot().item+"\\"+temp.tree.getRateOfRoot()+"; ");            temp = temp.next;        }     System.out.println(temp.tree.getRoot().item+"\\"+temp.tree.getRateOfRoot());  }

  /**    * 内部类     * @author LiangYH    *     */   class LinkNode{       LinkNode next = null;        HuffmanTest tree;

      public LinkNode(HuffmanTest tree){            this.tree = tree;        } }

}