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

8.4.2 Location-Aware Entries
In order to implement methods remove, replaceKey, and replaceValue of
an adapt able priority queue P, we need a mechanism for finding the position of an
entry of P. Namely, given the entry e of P passed as an argument to one of the above
methods, we need to find the position storing e in the the data structure imple menting
P (for example, a doubly linked list or a heap). This position is called the location of
the entry.
Instead of searching for the location of a given entry e, we augment the entry object
with an instance variable of type Position storing the location. This im
plementation of an entry that keeps track of its position is called a location-aware
entry. A summary description of the the use of location-aware entries for the sorted
list and heap implementations of an adaptable priority queue is provided below. We
denote the number of entries in the priority queue at the time an operation is per
formed, with n.
• Sorted list implementation. In this implementation, after an entry is inserted, we
set the location of the entry to refer to the position of the list containing the entry.
Also, we update the location of the entry whenever it changes position in the list.
Operations remove(e) and replaceValue(e,x) take O(1) time, since we can
obtain the position p of entry e in O(1) time following the location reference stored
with the entry. Instead, operation replaceKey(e, k) runs in O(n) time, because
the modification of the key of entry e may require moving the entry to a different
position in the list to preserve the ordering of the keys. The use of location-aware
entries increases the running time of the standard priority queue operations by a
constant factor.
• Heap implementation. In this implementation, after an entry is inserted, we set
the location of the entry to refer to the node of the heap containing the entry. Also,
we update the location of the entry whenever it changes node in the heap (for
example, because of the swaps in a down-heap or up-heap bubbling). Operation
replaceValue(e,x) takes O(1) time since we can obtain the position p of entry e
in O(1) time following the location reference stored with the entry. Operations
remove(e) and replaceKey(e,k) run instead in O(logn) (details are explored in
Exercise C-8.22). The use of location-aware entries increases the running time of
operations insert and removeMin by a constant factor overhead.
The use of location-aware entries for the unsorted list implementation is explored in
Exercise C-8.21.
Performance of Adaptable Priority Queue
Implementations
498