HuffmanCoding

用Java实现的huffman编码树(仅对26个字符）。
1.使用的是26字符的频率作为各字符的权值
2.使用到最小堆，用java.util.PriorityQueue类实现。
3.各huffman node需要实现java.lang.Comparable接口

/**
* HuffmanTreeNode.java
*/
package Huffman;
/**
* @function :
* @author     :hjh
* @company    :fdu
* @date         :2009-10-23
*/
public class HuffmanTreeNode implements Comparable<HuffmanTreeNode>{
  private char ch; //if node is leaf, this value is valid  
  private boolean leaf;
  private float weight;//frequency
  private HuffmanTreeNode leftChild;
  private HuffmanTreeNode rightChild;
  private String huffmanCode;
  
  /**
    * @param c
    * @param weight
    */
  public HuffmanTreeNode(char c, float weight) {
    // constructor for leaf node
    this.ch = c;
    this.weight = weight;
    this.leaf = true;
    this.leftChild = null;
    this.rightChild = null;
    this.huffmanCode = "";
  }
  public HuffmanTreeNode(float weight,HuffmanTreeNode leftChild,HuffmanTreeNode rightChild) {
    // constructor for none-leaf node
    this.ch = '#';
    this.weight = weight;
    this.leaf = false;
    this.leftChild = leftChild;
    this.rightChild = rightChild;
    this.huffmanCode = "";
  }
  public char getCh() {
    return ch;
  }
  public void setCh(char ch) {
    this.ch = ch;
  }
  public boolean isLeaf() {
    return leaf;
  }
  public void setLeaf(boolean leaf) {
    this.leaf = leaf;
  }
  public float getWeight() {
    return weight;
  }
  public void setWeight(float weight) {
    this.weight = weight;
  }
  public HuffmanTreeNode getLeftChild() {
    return leftChild;
  }
  public void setLeftChild(HuffmanTreeNode leftChild) {
    this.leftChild = leftChild;
  }
  public HuffmanTreeNode getRightChild() {
    return rightChild;
  }
  public void setRightChild(HuffmanTreeNode rightChild) {
    this.rightChild = rightChild;
  }
  public String getHuffmanCode() {
    return huffmanCode;
  }
  public void setHuffmanCode(String huffmanCode) {
    this.huffmanCode = huffmanCode;
  }

  /* (non-Javadoc)
    * @see java.lang.Comparable#compareTo(java.lang.Object)
    */
  @Override
  public int compareTo(HuffmanTreeNode o) {
    return weight==o.weight?0:(weight<o.weight?-1:1);
  }
  public String toString(){    
    return weight+"@"+huffmanCode+"@"+ch;
  }  
}

主函数

/**
* HuffmanCoding.java
*/
package Huffman;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.PriorityQueue;

/**
* @function :
* @author     :hjh
* @company    :fdu
* @date         :2009-10-23
*/
public class HuffmanCoding {
  
  //the symbol table of 26 characters
  static HuffmanTreeNode[] nodes=new HuffmanTreeNode[26];  
  
  static void initial() {

    BufferedReader br = null;
    try {
      br = new BufferedReader(new FileReader("bin/resource/abcfreqs.txt"));
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    String line = null;
    try {
      line = br.readLine();
    } catch (IOException e) {
      e.printStackTrace();
    }
    float[] freqs = new float[26];
    char[] chars=new char[26];
    String[] strs = line.split(" ");
    for (int i = 0,j=0; i<chars.length && j < strs.length; i++,j+=2) {
      chars[i]= strs[j].charAt(0);
      freqs[i] = Float.valueOf(strs[j+1]) * 0.01f;      
      nodes[i]=new HuffmanTreeNode(chars[i],freqs[i]);
    }    
  }
  
  public static void main(String args[]){
    initial();
    //create a minimum heap
    PriorityQueue<HuffmanTreeNode> minHeap = new PriorityQueue<HuffmanTreeNode>();
    for (HuffmanTreeNode node : nodes) {
      minHeap.offer(node);
    }
    HuffmanTreeNode root=genHuffmanTree(minHeap);
    dfsEncoding(root);        
    enCoding();
  }
  
  private static void enCoding() {  
    try {
      BufferedReader br = new BufferedReader(new FileReader("bin/resource/input.txt"));
      BufferedWriter bw = new BufferedWriter(new FileWriter("bin/resource/output.txt", false));

      String line;
      while ((line = br.readLine()) != null) {
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < line.length(); i++) {
          char c = line.charAt(i);
          String huffcode=nodes[c-'A'].getHuffmanCode();
          buf.append(huffcode);
        }        
        bw.write(buf.toString());
        bw.newLine();
      }
      bw.flush();
      bw.close();
      br.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  private static void dfsEncoding(HuffmanTreeNode root) {
    if(root==null)
      return;
    if(root.getLeftChild()==null && root.getRightChild()==null){
      //System.out.println(root);
      return;
    }
    if(root.getLeftChild()!=null){
      root.getLeftChild().setHuffmanCode(root.getHuffmanCode()+"0");
      dfsEncoding(root.getLeftChild());
    }
    if(root.getRightChild()!= null){
      root.getRightChild().setHuffmanCode(root.getHuffmanCode()+"1");
      dfsEncoding(root.getRightChild());
    }
    
  }

  /**
    *
    * @param minHeap
    * @return
    */
  private static HuffmanTreeNode genHuffmanTree(PriorityQueue<HuffmanTreeNode> minHeap) {
    while (!minHeap.isEmpty()) {
      HuffmanTreeNode n1 = minHeap.poll();
      if(minHeap.isEmpty())
        return n1;
      HuffmanTreeNode n2 = minHeap.poll();
      float weight=n1.getWeight()+n2.getWeight();
      HuffmanTreeNode s = new HuffmanTreeNode(weight,n1,n2);
      minHeap.offer(s);
    }
    return null;
  }
}