将值添加到优先级队列时，何时对值进行准确排序？

Question

Consider this pseudo-code:

PriorityQueue <Integer> pq = new PriorityQueue(new Comparator()
{
    public int compare(Object o1, Object o2) 
    {
         Integer e1 = (Integer)o1;
         Integer e2 = (Integer)o2;
         if (e1 > e2) {return -1;}
         if (e2 > e1) {return 1;}
         return 0;
     }
});

pq.add(4);
pq.add(7);
pq.add(5);
pq.add(2);
pq.add(9);

Now I'm wondering, when exactly during the run time does the queue run the compare() method? I assumed that it would follow this order:

i) First the numbers 4,7,5,2,9 are added to the queue in that order

ii) Then the priority queue uses the compare method to sort the values

In other words, the values are first inserted into the queue. Then they are sorted. Is this thinking correct? Or are the values sorted as they're being added to the queue?

Answer 1

PriorityQueues are not a simple sorted data structures like kind of sorted array. PriorityQueue in java was implemented using priority heaps. You should learn how heaps work, but basically when you add a new element, maximum log(n) comparisons occurs. Comparing all elements with each other is not necessary. You can learn more about priority queues at https://en.m.wikipedia.org/wiki/Priority_queue

Answer 2

PriorityQueue class has a private field Comparator defined for the insertion order ( private final Comparator<? super E> comparator )... so when you do:

PriorityQueue<Integer> pq = new PriorityQueue<>(foo);

where foo is an instance of the comparator, that object will be initialized internally for that instance...

after the collection is created, you begin to add elements to it and here is where the magic happens.

just look inside the PriorityQueue class and you will find the method siftUpUsingComparator , that will be invoked, and uses the comparator you defined to verify the insertion order...

private void siftUpUsingComparator(int k, E x) {
    while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (comparator.compare(x, (E) e) >= 0)
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = x;
}

---

Offtopic:

you are using raw collections and that is bad, I sugest to adapt your code to something like:

Comparator<Integer> foo = (o1, o2) -> {
    Integer e1 = o1;
    Integer e2 = o2;
    if (e1 > e2) {
        return -1;
    }
    if (e2 > e1) {
        return 1;
    }
    return 0;
};
PriorityQueue<Integer> pq = new PriorityQueue<>(foo);

pq.add(4);
pq.add(7);
pq.add(5);
pq.add(2);
pq.add(9);