Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

at the time the method is executed. Moreover, these methods run in time
proportional to n even in the best case, since they each require searching the entire
list to find a minimum-key entry. That is, using the notation of Section 4.2.3, we
can say that these methods run in θ(n) time. Finally, we implement methods size
and isEmpty by simply returning the output of the corresponding methods
executed on list S.
Thus, by using an unsorted list to implement a priority queue, we achieve
constant-time insertion, but linear-time search and removal.
8.2.2 Implementation with a Sorted List
An alternative implementation of a priority queue P also uses a list S, except that
this time let us store the entries sorted by key. Specifically, we represent the priority
queue P by using a list S of entries sorted by nondecreasing keys, which means that
the first element of S is an entry with the smallest key.
Fast Removals and Slow Insertions
We can implement method min in this case simply by accessing the first element
of the list with the first method of S. Likewise, we can implement the
removeMin method of P as S.remove(S.first()). Assuming that S is
implemented with a doubly linked list, operations min and removeMin in P
take O(1) time. Thus, using a sorted list allows for simple and fast
implementations of priority queue access and removal methods.
This benefit comes at a cost, however, for now method insert of P requires that
we scan through the list S to find the appropriate position to insert the new entry.
Thus, implementing the insert method of P now takes O(n) time, where n is the
number of entries in P at the time the method is executed. In summary, when
using a sorted list to implement a priority queue, insertion runs in linear time
whereas finding and removing the minimum can be done in constant time.
Comparing the Two List-Based Implementations
Table 8.2 compares the running times of the methods of a priority queue realized
by means of a sorted and unsorted list, respectively. We see an interesting tradeoff
when we use a list to implement the priority queue ADT. An unsorted list
allows for fast insertions but slow queries and deletions, while a sorted list allows
for fast queries and deletions, but slow insertions.
Table 8.2: Worst-case running times of the
methods of a priority queue of size n, realized by
461