Priority queue ordering of elements

问题

How come the elements of priority queue are ordered according to natural order by default as it doesn't implement comparable interface.

From the docs, it says elements are ordered based on natural ordering but I can't find anywhere it talks about equals method nor comparable. Hows it happening internally?

All Implemented Interfaces: Serializable, Iterable, Collection, Queue.

If it implements comparable then why doesn't it say in the above line

Example:

    public static void main(String[] args) {
        PriorityQueue<String> pq = new PriorityQueue<String>();
        pq.add("2");
        pq.add("4");
        System.out.println(pq); //prints [2, 4]
        pq.offer("1");
        System.out.println(pq); // prints [1, 4, 2]
        pq.add("3");
        System.out.println(pq); // prints [1, 3, 2, 4]
    }
}

Also third print statement prints [1, 3, 2, 4] instead of prints [1, 2, 3, 4]. Why? It should be natural ordering right?

回答1:

Actually internal data structure of PriorityQueue is not ordered, it is a heap.

PriorityQueue doesn't need to be ordered, instead, it focuses on head of data. Insertion is in O(log n) time. Sorting wastes time and useless for a queue.

Moreover, either the element is-a Comparable, or a Comparator is provided. Unfortunately, non-comparable checking is at runtime, rather than compile time. Once second element is added, ClassCastException occurs.

PLUS: My answer to why [1, 3, 2, 4] instead of prints [1, 2, 3, 4]?

As I mentioned before, it's not ordered, instead it focuses on head q[0] is minimum, that's it. You could see the [1, 3, 2, 4] as a tree which is NOT linear:

1
| \
3  2
|
4

回答2:

You are seeing that order because:

1. Internally System.out.println() will be invoking the toString() method which in turn uses the iterator to iterate through the elements of the queue. But the iterator does not guarantee any specific order to traverse the elements. Refer this

http://docs.oracle.com/javase/6/docs/api/java/util/PriorityQueue.html

2. Priority queue is based on priority heap. When an element is inserted without any comparator then priority queue uses siftUpComparable() method internally. siftUpComparable() compares the current element with the element at it's parent position in the heap. If the order is not correct then current element and parent element are swapped. This is done until the current element and parent element are in correct order. Ordering is based on natural order of the element.

3. Since priority queue is based on priority heap its main focus will be on element in front of the queue. So the elements are ordered when an element is dequeued from the queue using poll(). This is done to increase the performance of Priority queue. Priority queue only orders the elements when it requires.
If you want to see the order as [1, 2, 3, 4] then use this

while(pq.size() != 0) { 
    System.out.println(pq.poll());
}

回答3:

The priority queue relies on the following to order the elements:

Element must be a Comparable type
Need to provide Comparator implementation for the queue

回答4:

Actually PriorityQueue allows only those elements which implements Comparable or you need to provide Custom Comparator.

Integer and String values are allowed in Comparator because they implement Comparable interface. e.g. public final class String implements java.io.Serializable, Comparable, CharSequence

public final class Integer extends Number implements Comparable

If you create your own class e.g Employee then it should implement Comparable or you should provide your custom Comparator.

I hope this will resolve your queries!!!!

来源：https://stackoverflow.com/questions/30072077/priority-queue-ordering-of-elements

标签

java

scjp