Huffman compression problem

Question

I am trying to get a character count from an ASCII file. So i read byte by byte and store bytes into an array.
I'm using priority queue (heap) for storing the characters and their frequencies in an object, for the huffman tree.
So my question is what is the easiest way to count the character frequencies so that i can put them into the priority queue?
Should insert into PQ once i have a character count for the entire file, or while i am going through character by character ?

Answer 1

I know it's a spoiler and a give-away, but it's Saturday and I have to
make up with what happened the last couple of days. Have a look:import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
abstract class HuffmanNode implements Comparable {
     private static int seq= 0;
     protected int freq;
     protected int code;
     public int getFreq() { return freq; }
     public int getCode() { return code; }     
     protected void incFreq() { freq++; }
     public HuffmanNode(int freq) { this.freq= freq; code= seq++; }
     abstract protected void add(int b);
     public int compareTo(Object obj) {
          HuffmanNode that= (HuffmanNode)obj;
          if (this.freq == that.freq)
               return this.code-that.code;
          else
               return this.freq-that.freq;
class LeafNode extends HuffmanNode {
     private char chr;
     private int len;
     public LeafNode(char chr, int freq) { super(freq); this.chr= chr; }
     protected void add(int bit) {
          code&= (1<<len)-1;
          code<<= 1;
          code|=  bit;
          len++;
     public String toString() { return "["+chr+":"+code+","+len+"]"; }
class CombNode extends HuffmanNode {
     private HuffmanNode lft;
     private HuffmanNode rgt;
     public CombNode(HuffmanNode lft, HuffmanNode rgt) {
          super(lft.getFreq()+rgt.getFreq());
          this.lft= lft; lft.add(0);
          this.rgt= rgt; rgt.add(1);
     protected void add(int bit) { lft.add(bit); rgt.add(bit); }
     public String toString() { return "["+lft+","+rgt+"]"; }
public class Huffman {
     private Map table= new HashMap();
     public void add(char c) {
          Character key= new Character(c);
          HuffmanNode node= (HuffmanNode)table.get(key);
          if (node == null) {
               node= new LeafNode(c, 0);
               table.put(key, node);
          node.incFreq();               
     public HuffmanNode build() {
          TreeSet tree= new TreeSet(table.values());
          while (tree.size() >= 2) {
               HuffmanNode lft= (HuffmanNode)tree.first(); tree.remove(lft);
               HuffmanNode rgt= (HuffmanNode)tree.first(); tree.remove(rgt);
               tree.add(new CombNode(lft, rgt));
          return (HuffmanNode)tree.first();
}Note that I carefully removed all comments (just to give you something
to study) and also note how I cleverly (ahem) left the sorting business
to the Collection stuff (me being a lazy bum). Simply create a Huffman
object, add all your characters to it and let the object build
the Huffman tree. Note that this is not an industrial strenght Huffman
compression implementation by far, for reasons that are beyond the
scope of your question.
kind regards,
Jos