霍夫曼编码树-优先队列出现故障

Question

I'm trying to write a program for calculating Huffman codes for each character in a string.

Here's my code::

import java.util.Collections;
import java.util.PriorityQueue;

public class HuffmanCode{
    PriorityQueue<Node> queue = new PriorityQueue<Node>();
    PriorityQueue<Node> queueCopy = new PriorityQueue<Node>();

    public void getCodes(String text) {
        int[] count = countOccurences(text);
        fillQueue(count);
        makeHuffmanTree();
        assignCodes();
        displayCodes();
    }

    public int[] countOccurences(String text) {
        int[] letters = new int[256];
        for(int i = 0; i < text.length(); i++) {
            letters[(int)(text.charAt(i))]++;
        }
        return letters;
    }

    public void fillQueue(int[] count) {
        for(int i = 0; i < count.length; i++) {
            if(count[i] != 0) {
                queue.offer(new Node((char)i, count[i]));
                queueCopy.offer(new Node((char)i, count[i]));
            }
        }
    }

    public void makeHuffmanTree() {
        if(queue.size() > 1) {
            Node node1 = queue.remove();
            Node node2 = queue.remove();
            queue.offer(new Node(node1, node2));
            makeHuffmanTree();
        }
    }

    public void assignCodes() {
        assignCodes(queue.remove(), "");
    }

    public void assignCodes(Node root, String code) {
        if(root.left != null) 
            assignCodes(root.left, code + "0");
        if(root.right!= null) 
            assignCodes(root.right, code + "1");
        if(root.left == null && root.right == null)
            root.code = code + "";
    }

    public void displayCodes() {
        for(Node n: queue)
            System.out.println(n.character + " -> " + n.weight + " -> " + n.code);
    }
}

Here's the Node class::

public class Node implements Comparable<Node>{
    char character;
    int weight;
    Node left;
    Node right;
    String code = "";

    Node(char character, int weight) {
        this.character = character;
        this.weight = weight;
    }

    Node(Node node1, Node node2) {
        weight = node1.weight + node2.weight;
        left = node1;
        right = node2;
    }

        }@Override
    public int compareTo(Node e) {
        if(this.weight < e.weight)
            return -1;
        else if(this.weight == e.weight)
            return 0;
        else
            return 1;
    }
}

If you debug the above code, you'll note that the elements in queue are not properly sorted. If text is 'Mississipi', for example, then queue contains M,i,p,s - which is wrong (because, M occurred once, i occured 4 times, p once and s occured 4 times). It should be M,p,s,i.

UPDATE

I replaced my compareTo method with:

@Override
public int compareTo(Node e) {
if(this.weight < e.weight)
    return 1;
else if(this.weight == e.weight)
    return 0;
else
    return -1;
}

Now, though the ordering is opposite to what's required, the sorting is correct. This time, when I entered Mississipi , the queue contained 'i,s,p,M'

Answer 1

From the Javadoc for PriorityQueue

The head of this queue is the least element with respect to the specified ordering. If multiple elements are tied for least value, the head is one of those elements -- ties are broken arbitrarily. The queue retrieval operations poll, remove, peek, and element access the element at the head of the queue.

And for PriorityQueue.iterator()

public Iterator iterator() Returns an iterator over the elements in this queue. The iterator does not return the elements in any particular order.

If you want a structure which is sorted you can use a TreeSet.