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

emoveMin operations play an important role. We consider such an application
in the example that follows.
Example 8.1: Suppose a certain flight is fully booked an hour prior to
departure. Because of the possibility of cancellations, the airline maintains a
priority queue of standby passengers hoping to get a seat. The priority of each
standby passenger is determined by the airline taking into account the fare paid,
the frequent-flyer status, and the time that the passenger is inserted into the
priority queue. A standby passenger reference is inserted into the priority queue
with an insert operation as soon as he or she requests to fly standby. Shortly
before the flight departure, if seats become available (for example, due to noshows
or last-minute cancellations), the airline removes a standby passenger with
first priority from the priority queue, using aremoveMin operation and lets this
person board. This process is then repeated until all available seats have been
filled or the priority queue becomes empty.
8.1.2 Entries and Comparators
There are still two important issues that we have left undetermined to this point:
• How do we keep track of the associations between keys and values?
• How do we compare keys so as to determine a smallest key?
Answering these questions involves the use of two interesting design patterns.
The definition of a priority queue implicitly makes use of two special kinds of
objects that answer the above questions, the entry and comparator, which we
discuss in this subsection.
Entries
An entry is an association between a key k and a value x, that is, an entry is
simply a key-value pair. We use entries in a priority queue Q to keep track of the
way Q is associating keys and their corresponding values.
An entry is actually an example of a more general object-oriented design pattern,
the composition pattern, which defines a single object that is composed of other
objects. We use this pattern in a priority queue when we define the entries being
stored in the priority queue to be pairs consisting of a key k and a value x. A pair
is the simplest composition, for it combines two objects into a single pair object.
To implement this concept, we define a class that stores two objects in its first and
second instance variables, respectively, and provides methods to access and
update these variables. In Code Fragment 8.1, we show an implementation of the
composition pattern for entries storing key-value pairs in a priority queue. We
realize this composition with an interface called Entry (the java.util
452