Transcript Document

Queues
Briana B. Morrison
Adapted from Alan Eugenio
Topics



Define Queue
APIs
Applications



Radix Sort
Simulation
Implementation

Array based

Circular




Empty, one value, full
Linked list based
Deques
Priority Queues
Queues
2
A QUEUE IS A CONTAINER IN WHICH:
. INSERTIONS ARE MADE ONLY AT
THE BACK;
. DELETIONS, RETRIEVALS, AND
MODIFICATIONS ARE MADE ONLY
AT THE FRONT.
Queues
3
The Queue
A
push A
front
back
A
B
push B
front back
A
B
front
B
C push C
back
C
pop A
A Queue is a FIFO
(First in First Out)
Data Structure.
Elements are inserted
in the Rear of the
queue and are
removed at the Front.
front back
C
pop B
front
back
Queues
4
PUSH (ALSO CALLED ENQUEUE) -- TO
INSERT AN ITEM AT THE BACK
POP (ALSO CALLED DEQUEUE) -- TO
DELETE THE FRONT ITEM
IN A QUEUE, THE FIRST ITEM
INSERTED WILL BE THE FIRST ITEM
DELETED: FIFO (FIRST-IN, FIRST-OUT)
Queues
5
METHOD INTERFACES
FOR THE
queue CLASS
Queues
6
CLASS queue
Constructor
<queue>
Operations
<queue>
queue();
Create an empty queue.
CLASS queue
bool empty() const;
Check whether the queue is empty. Return true if it is
empty and false otherwise.
T& front();
Return a reference to the value of the item at the font
of the queue.
Precondition: The queue is not empty.
Queues
7
CLASS queue
Operations
<queue>
const T& front() const;
Constant version of front().
void pop();
Remove the item from the front of the queue.
Precondition: The queue is not empty.
Postcondition: The element at the front of the queue
is the element that was added
immediately after the element just
popped or the queue is empty.
Queues
8
CLASS queue
Operations
<queue>
void push(const T& item);
Insert the argument item at the back of the queue.
Postcondition: The queue has a new item at the back
int size() const;
Return the number of elements in the queue.
Queues
9
THERE ARE NO ITERATORS!
THE ONLY ACCESSIBLE ITEM IS THE
FRONT ITEM.
Queues
10
DETERMINE THE OUTPUT FROM THE
FOLLOWING:
queue<int> my_queue;
for (int i = 0; i < 10; i++)
my_queue.push (i * i);
while (!my_queue.empty())
{
cout << my_queue.front() << endl;
my_queue.pop();
} // while
Queues
11
THE queue CLASS IS TEMPLATED:
template <class T, class Container = deque<T> >
T IS THE TEMPLATE PARAMETER
FOR THE ITEM TYPE. Container IS THE
TEMPLATE PARAMETER FOR THE
CLASS THAT WILL HOLD THE ITEMS,
WITH THE deque CLASS THE DEFAULT.
Queues
12
THE queue CLASS IS A CONTAINER
ADAPTOR. A CONTAINER ADAPTOR C
CALLS THE METHODS FROM SOME
OTHER CLASS TO DEFINE THE
METHODS IN C.
Queues
13
SPECIFICALLY, THE queue CLASS
ADAPTS ANY CONTAINER CLASS
THAT HAS push_back, pop_front, front,
size, AND empty METHODS.
deque?
OK
list?
OK
vector?
NOT OK: NO pop_front METHOD
Queues
14
Implementing Queue: adapter of std::list

This is a simple adapter class, with following mappings:

Queue push maps to push_back
Queue front maps front
Queue pop maps to pop_front

...






This is the approach taken by the C++ standard library.
Any sequential container that supports push_back,
front, and pop_front can be used.
The list
The deque
Queues
15
THE STANDARD C++ REQUIRES THAT
THE DEFINITION OF THE queue
CLASS INCLUDE
protected:
Container c;
Queues
16
ALSO, THE METHOD DEFINITIONS
ARE PRESCRIBED. FOR EXAMPLE,
public:
void push (const value_type& x) { c.push_back (x)); }
void pop( ) { c.pop_front( ); }
const T& front( ) const { return c.front( ); }
Queues
17
miniQueue<int> miniQ; // declare an empty queue
Queue Statement Queue
miniQ.push(10)
List Statement
qlist.push_back(10)
10
frontback
miniQ.push(25)
10
List
front back
qlist.push_back(25)
25
front back
miniQ.push(50)
10
25
front
50
qlist.push_back(50)
back
back
10
25
50
front
return qlist.front()
miniQ.pop()
qlist.pop_front()
50
25
10
front
n = miniQ.front() // n = 10
25
10
back
// return 10
25
50
front back
Queues
18
IF EITHER A DEQUE OR LIST IS THE
UNDERLYING CONTAINER,
worstTime(n) IS CONSTANT FOR EACH
METHOD.
EXCEPTION: FOR THE push METHOD,
IF A DEQUE IS THE UNDERLYING
CONTAINER, worstTime(n) IS LINEAR IN
n, AND averageTime(n) IS CONSTANT
(AND amortizedTime(n) IS CONSTANT).
Queues
19
Applications of Queues

Direct applications




Waiting lists, bureaucracy
Access to shared resources (e.g., printer)
Multiprogramming
Indirect applications


Auxiliary data structure for algorithms
Component of other data structures
Queues
20
APPLICATION OF QUEUES:
RADIX SORT
Queues
21
The Radix Sort
Order ten 2 digit numbers in 10 bins from smallest
number to largest number. Requires 2 calls to the sort
Algorithm.
Initial Sequence: 91 6 85 15 92 35 30 22 39
Pass 0:
Distribute the cards into bins according
to the 1's digit (100).
30
91
22
92
0
1
2
3
35
15
85
6
5
6
4
Queues
39
7
8
9
22
The Radix Sort
After Collection: 30 91 92 22 85 15 35 6 39
Pass 1: Take the new sequence and distribute the
cards into bins determined by the 10's digit (101).
Final Sequence: 6 15 22 30 35 39 85 91 92
6
15
22
39
35
30
0
1
2
3
4
5
Queues
6
7
85
92
91
8
9
23
Radix Sort
Use an array of queues (or vector of queues) as the “buckets”
void radixSort (vector<int>& v, int d)
{
int i;
int power = 1;
queue<int> digitQueue[10];

for (i=0;i < d;i++)
{
distribute(v, digitQueue, power);
collect(digitQueue, v);
power *= 10;
}
}
Queues
24
// support function for radixSort()
// distribute vector elements into one of 10 queues
// using the digit corresponding to power
// power = 1 ==> 1's digit
// power = 10 ==> 10's digit
// power = 100 ==> 100's digit
// ...
void distribute(const vector<int>& v, queue<int> digitQueue[],
int power)
{
int i;
// loop through the vector, inserting each element into
// the queue (v[i] / power) % 10
for (i = 0; i < v.size(); i++)
digitQueue[(v[i] / power) % 10].push(v[i]);
}
Queues
25
// support function for radixSort()
// gather elements from the queues and copy back to the vector
void collect(queue<int> digitQueue[], vector<int>& v)
{
int i = 0, digit;
// scan the vector of queues using indices 0, 1, 2, etc.
for (digit = 0; digit < 10; digit++)
// collect items until queue empty and copy items back
// to the vector
while (!digitQueue[digit].empty())
{
v[i] = digitQueue[digit].front();
digitQueue[digit].pop();
i++;
}
}
Queues
26
APPLICATION OF QUEUES:
COMPUTER SIMULATION
Queues
27
A SYSTEM IS A COLLECTION OF
INTERACTING PARTS.
A MODEL IS A SIMPLIFICATION OF
A SYSTEM.
THE PURPOSE OF BUILDING A MODEL
IS TO STUDY THE UNDERLYING
SYSTEM.
Queues
28
PHYSICAL MODEL: DIFFERS FROM
THE SYSTEM ONLY IN SCALE OR
INTENSITY.
EXAMPLES: WAR GAMES, PRE-SEASON
Queues
29
MATHEMATICAL MODEL: A SET OF
EQUATIONS, VARIABLES, AND
ASSUMPTIONS
Queues
30
A
500’
D
?
200’
500’
B
C
400’
E
ASSUMPTIONS: ANGLE ADC = ANGLE BCD
BEC FORMS A RIGHT TRIANGLE
DCE FORMS A STRAIGHT LINE
LINE SEGMENT AB PARALLEL TO DC
DISTANCE FROM A TO B?
Queues
31
IF IT IS INFEASIBLE TO SOLVE THE
MATH MODEL (THAT IS, THE
EQUATIONS) BY HAND, A PROGRAM
IS DEVELOPED.
COMPUTER SIMULATION: THE
DEVELOPMENT OF COMPUTER
PROGRAMS TO SOLVE MATH MODELS
Queues
32
DEVELOP
System
Computer
Model
VERIFY
RUN
Interpretation
Output
DECIPHER
Queues
33
IF THE INTERPRETATION DOES NOT
CORRESPOND TO THE BEHAVIOR OF
THE SYSTEM, CHANGE THE MODEL!
Queues
34
Simulating Waiting Lines Using Queues

Simulation is used to study the performance:



Simulation allows designers to estimate
performance


Of a physical (“real”) system
By using a physical, mathematical, or computer model of
the system
Before building a system
Simulation can lead to design improvements

Giving better expected performance of the system
Queues
35
Simulating Waiting Lines Using Queues

Simulation is particular useful when:



Building/changing the system is expensive
Changing the system later may be dangerous
Often use computer models to simulate “real”
systems


Airline check-in counter, for example
Special branch of mathematics for these problems:
Queuing Theory
Queues
36
Simulate Strategies for Airline Check-In
Queues
37
Simulate Airline Check-In

We will maintain a simulated clock


1.
2.
3.
4.
5.
Counts in integer “ticks”, from 0
At each tick, one or more events can
happen:
Frequent flyer (FF) passenger arrives in line
Regular (R) passenger arrives in line
Agent finishes, then serves next FF
passenger
Agent finishes, then serves next R
passenger
Agent is idle (both lines empty)
Queues
38
Simulate Airline Check-In

Simulation uses some parameters:





Max # FF served between regular passengers
Arrival rate of FF passengers
Arrival rate of R passengers
Service time
Desired output:


Statistics on waiting times, agent idle time, etc.
Optionally, a detailed trace
Queues
39
Simulate Airline Check-In

Design approach:




Agent data type models airline agent
Passenger data type models passengers
2 queue<Passenger>, 1 for FF, 1 for R
Overall Airline_Checkin_Sim class
Queues
40
Simulate Airline Check-In
Queues
41
QUEUE APPLICATION
A SIMULATED CAR WASH
Queues
42
PROBLEM:
GIVEN THE ARRIVAL TIMES AT
SPEEDY’S CAR WASH, CALCULATE THE
AVERAGE WAITING TIME PER CAR.
Queues
43
ANALYSIS:
ONE WASH STATION
10 MINUTES FOR EACH CAR TO GET
WASHED
AT ANY TIME, AT MOST 5 CARS
WAITING TO BE WASHED; ANY OTHERS
TURNED AWAY AND NOT COUNTED
Queues
44
AVERAGE WAITING TIME = SUM OF
WAITING TIMES / NUMBER OF CARS
IN A GIVEN MINUTE, A DEPARTURE IS
PROCESSED BEFORE AN ARRIVAL.
Queues
45
IF A CAR ARRIVES WHEN NO CAR IS
BEING WASHED AND NO CAR IS
WAITING, THE CAR IMMEDIATELY
ENTERS THE WASH STATION.
A CAR STOPS WAITING WHEN IT
ENTERS THE WASH STATION.
SENTINEL IS 999.
Queues
46
SYSTEM TEST 1:
8
11
11
13
14
16
16
20
999
Queues
47
TIME
8
11
11
13
14
16
16
18
20
28
38
48
58
68
78
EVENT
WAITING TIME
ARRIVAL
ARRIVAL
ARRIVAL
ARRIVAL
ARRIVAL
ARRIVAL
ARRIVAL (OVERFLOW)
DEPARTURE
0
ARRIVAL
DEPARTURE
7
DEPARTURE
17
DEPARTURE
25
DEPARTURE
34
DEPARTURE
42
DEPARTURE
48
Queues
48
AVERAGE WAITING TIME
= 173 / 7.0 MINUTES
= 24.7 MINUTES
Queues
49
CAR WASH APPLET
http://www.cs.lafayette.edu/~collinsw/carwash/car.html
Queues
50
Implementing a Queue

Array based

Where is front? Where is top?



Array suffers from “rightward” drift
To solve, use circular array
How are elements added, removed?




Using circular array, a new problem arises
What does empty look like?
What does single element look like?
What does full look like?
Queues
51
Array-based Queue


Use an array of size N in a circular fashion
Two variables keep track of the front and rear
f index of the front element
r index immediately past the rear element

Array location r is kept empty
normal configuration
Q
0 1 2
f
r
wrapped-around configuration
Q
0 1 2
r
f
Queues
52
Implementing queue With a Circular Array
Basic idea: Maintain two integer indices into an array
 front: index of first element in the queue
 rear: index of the last element in the queue
 Elements thus fall at front through rear
Key innovation:
 If you hit the end of the array wrap around to slot 0
 This prevents our needing to shift elements around

Still have to deal with overflow of space
Queues
53
Implementing Queue With Circular Array
Queues
54
Implementing Queue With Circular Array
Queues
55
Implementing Queue With Circular Array
Queues
56
The Bounded queue
qback
qfront
qback
qback
qback
D
A
C
B
C
C
C
B
qfront
qfront
Insert elements A,B, C Remove element A Remove element B
D
C
qback
D
E
C
qback
qfront
Insert element D,
D
E
D
qfront
qback qfront
Insert element D, Insert element E
Array View
qfront C
qfront C
qback
Insert element D, Insert element E
Circular View
Queues
57
Methods to Implement

i = (( i + 1) == max) ? 0 : (i + 1);

if (( i + 1) == max) i = 0; else i = i + 1;

i = ( i + 1) % max;
Queues
58
Queue Operations

We use the
modulo operator
(remainder of
division)
Algorithm size()
return (N - f + r) mod N
Algorithm isEmpty()
return (f = r)
Q
0 1 2
f
0 1 2
r
r
Q
f
Queues
59
Queue Operations (cont.)


Operation enqueue throws
an exception if the array is
full
This exception is
implementation-dependent
Algorithm enqueue(o)
if size() = N - 1 then
throw FullQueueException
else
Q[r]  o
r  (r + 1) mod N
Q
0 1 2
f
0 1 2
r
r
Q
f
Queues
60
Queue Operations (cont.)


Operation dequeue
throws an exception if
the queue is empty
This exception is
specified in the queue
ADT
Algorithm dequeue()
if isEmpty() then
throw EmptyQueueException
else
o  Q[f]
f  (f + 1) mod N
return o
Q
0 1 2
f
0 1 2
r
r
Q
f
Queues
61
Boundary Conditions
Queues
62
Implementation Considerations






The physical model: a linear array with the front
always in the first position and all entries moved up
the array whenever the front is deleted.
A linear array with two indices always increasing.
A circular array with front and rear indices and one
position left vacant.
A circular array with front and rear indices and a
Boolean flag to indicate fullness (or emptiness).
A circular array with front and rear indices and an
integer counter of entries.
A circular array with front and rear indices taking
special values to indicate emptiness.
Queues
63
Growable Array-based Queue



In an enqueue operation, when the array is
full, instead of throwing an exception, we can
replace the array with a larger one
Similar to what we did for an array-based
stack
The enqueue operation has amortized running
time


O(n) with the incremental strategy
O(1) with the doubling strategy
Queues
64
Implementing a Queue

Linked List based



Where is front? Where is back?
How are elements added, removed?
Efficiency of operations
Queues
65
Queue with a Singly Linked List


We can implement a queue with a singly linked list
 The front element is stored at the first node
 The rear element is stored at the last node
The space used is O(n) and each operation of the Queue
ADT takes O(1) time
r
nodes
f

elements
Queues
66
Implementing Queue: Singly-Linked List
This requires front and rear Node pointers:
template<typename Item_Type>
class queue {
. . .
private:
// Insert implementation-specific data fields
// Insert definition of Node here
#include "Node.h"
// Data fields
Node* front_of_queue;
Node* back_of_queue;
size_t num_items;
};
Queues
67
Using a Single-Linked List to
Implement a Queue (continued)
Queues
68
Implementing Queue: Singly-Linked List



Insert at tail, using back_of_queue for speed
Remove using front_of_queue
Adjust size when adding/removing

No need to iterate through to determine size
Queues
69
Analysis of the Space/Time Issues

Time efficiency of singly- or doubly-linked list good:
O(1) for all Queue operations

Space cost: ~3 extra words per item



vector uses 1 word per item when fully packed
2 words per item when just grown
On average ~1.5 words per item, for larger lists
Queues
70
Comparing the Three Implementations


All three are comparable in time: O(1) operations
Linked-lists require more storage



Singly-linked list: ~3 extra words / element
Doubly-linked list: ~4 extra words / element
Circular array: 0-1 extra word / element

On average, ~0.5 extra word / element
Queues
71
Analysis of the Space/Time Issues

vector Implementation




Insertion at end of vector is O(1), on average
Removal from the front is linear time: O(n)
Removal from rear of vector is O(1)
Insertion at the front is linear time: O(n)
Queues
72
DEQUES
Double Ended Queues
Queues
73
A DEQUE IS A FINITE SEQUENCE OF
ITEMS SUCH THAT
1. GIVEN ANY INDEX, THE ITEM IN
THE SEQUENCE AT THAT INDEX
CAN BE ACCESSED OR MODIFIED
IN CONSTANT TIME.
2. AN INSERTION OR DELETION AT
THE FRONT OR BACK OF THE
SEQUENCE TAKES ONLY
CONSTANT TIME, ON AVERAGE.
Queues
74
THE deque CLASS IS VERY SIMILAR TO
THE vector CLASS.
Queues
75
The deque



The deque is an abstract data type that
combines the features of a stack and a
queue.
The name deque is an abbreviation for
double-ended queue.
The C++ standard defines the deque as a
full-fledged sequential container that supports
random access.
Queues
76
The deque class
Member Function
Behavior
const Item_Type&
operator[](size_t index)const;
Item_Type&
operator[](size_t index)
const Item_Type&
at(size_t index) const;
Item_Type&
at(size_t index)
iterator insert(iterator pos,
const Item_Type& item)
Returns a reference to the element at position
index.
iterator erase(iterator pos)
void remove(const Item_Type&
item)
Returns a reference to the element at position
index. If index is not valid, the
out_of_range exception is thrown.
Inserts a copy of item into the deque at
position pos. Returns an iterator that
references the newly inserted item.
Removes the item from the deque at
position pos. Returns an iterator that
references the item following the one erased.
Removes all occurrences of item from the
deque.
Queues
77
The deque class (2)
Member Function
Behavior
void push_front(const Item_Type&
item)
void push_back(const Item_Type&
item)
void pop_front()
void pop_back()
Item_Type& front();
const Item_Type& front() const
Item_Type& back();
const Item_Type& back() const
iterator begin()
Inserts a copy of item as the first element of
the deque
Inserts a copy of item as the last element of
the deque.
Removes the first item from the deque.
Removes the last item from the deque.
Returns a reference to the first item in the
deque.
Returns a reference to the last item in the
deque.
Returns an iterator that references the
first item of the deque.
Returns a const_iterator that references
the first item of the deque.
const_iterator begin() const
Queues
78
The deque class (3)
Member Function
Behavior
Returns an iterator that references one
past the last item of the deque.
const_iterator end() const
Returns a const_iterator that references
one past the last item of the deque.
void swap(deque<Item_Type& other) Swaps the contents of this deque with the
other deque.
bool empty() const
Returns true if the deque is empty.
size_t size() const
Returns the number of items in the deque.
void resize(size_t new_size)
Changes the size of the deque to
new_size. If new_size is smaller than the
current size, then items are removed from
the end. If new_size is larger than the
current size, then default valued items are
added to the end.
iterator end()
Queues
79
TO TAKE ADVANTAGE OF INSERTIONS
AND DELETIONS AT THE FRONT OF A
DEQUE, THERE ARE TWO METHODS:
// Postcondition: A copy of x has been inserted at the front
//
of this deque. The averageTime(n) is
//
constant, and worstTime (n) is O(n) – but
//
for n consecutive insertions,
//
worstTime(n) is only O(n). That is,
//
amortizedTime(n) is constant.
void push_front (const T& x);
// Postcondition: The item at the front of this deque has
//
been deleted.
void pop_front( );
Queues
80
THE deque CLASS ALSO HAS ALL OF
THE METHODS FROM THE vector CLASS
(EXCEPT FOR capacity AND reserve),
AND THE INTERFACES ARE THE SAME!
Queues
81
deque<string>words;
string word;
What’s output?
for (int i = 0; i < 5; i++)
{
cin >> word;
words.push_back (word);
} // for
words.pop_front( );
words.pop_back( );
for (unsigned i = 0; i < words.size(); i++)
cout << words [i] << endl;
Queues
82
ON PAPER, THAT IS, LOOKING AT BIGO TIME ESTIMATES ONLY, A DEQUE IS
SOMETIMES FASTER AND NEVER
SLOWER THAN A VECTOR.
Queues
83
IN PRACTICE, THAT IS, LOOKING AT
RUN-TIMES, VECTORS ARE FASTER
EXCEPT FOR INSERTIONS AND
DELETIONS AT OR NEAR THE FRONT,
AND THERE DEQUES ARE MUCH
FASTER THAN VECTORS.
Queues
84
The Standard Library Implementation


The standard library uses a randomly
accessible circular array.
Each item in the circular array points to a
fixed size, dynamically allocated array that
contains the data.

The advantage of this implementation is that when
reallocation is required, only the pointers need to
be copied into the new circular array.
Queues
85
The Standard Library Implementation (2)
Queues
86
IN THE HEWLETT-PACKARD DESIGN
AND IMPLEMENTATION OF THE deque
CLASS, THERE IS A map FIELD: A
POINTER TO AN ARRAY. THE ARRAY
ITSELF CONTAINS POINTERS TO
BLOCKS THAT HOLD THE ITEMS. THE
start AND finish FIELDS ARE
ITERATORS.
Queues
87
map
start
yes
true
now
good
love
clear
right
finish
Queues
88
FOR CONTAINER CLASSES IN
GENERAL, ITERATORS ARE “SMART”
POINTERS. FOR EXAMPLE operator++
ADVANCES TO THE NEXT ITEM,
WHICH MAY BE AT A LOCATION FAR
AWAY FROM THE CURRENT ITEM.
Queues
89
DEQUE ITERATORS ARE GENIUSES!
Queues
90
THE iterator CLASS EMBEDDED IN THE
deque CLASS HAS FOUR FIELDS:
1. first, A POINTER TO THE
BEGINNING OF THE BLOCK;
2. current, A POINTER TO AN ITEM;
3. last, A POINTER TO ONE BEYOND
THE END OF THE BLOCK;
4. node, A POINTER TO THE
LOCATION IN THE MAP ARRAY
THAT POINTS TO THE BLOCK.
Queues
91
map
start
yes
true
now
good
love
clear
right
finish
Queues
92
SUPPOSE THE DEQUE SHOWN IN THE
PREVIOUS SLIDE IS words. HOW DOES
RANDOM ACCESS WORK? FOR
EXAMPLE, HOW IS words [5]
ACCESSED?
Queues
93
1. BLOCK NUMBER
= (index + offset of first item in first block) / block size
= (5 + start.current – start.first) / 4
= (5 + 2) / 4
=1
2. OFFSET WITHIN BLOCK
= (index+offset of first item in first block) % block size
=7%4
=3
Queues
94
THE ITEM AT words [5], AT AN OFFSET
OF 3 FROM THE START OF BLOCK 1, IS
“clear”.
Queues
95
FOR AN INSERTION OR REMOVAL AT
SOME INDEX i IN THE INTERIOR OF A
DEQUE, THE NUMBER OF ITEMS
MOVED IS THE MINIMUM OF i AND
length – i. THE length FIELD CONTAINS
THE NUMBER OF ITEMS.
Queues
96
FOR EXAMPLE, TO INSERT AT words [5],
THE NUMBER OF ITEMS MOVED IS 7 – 5
= 2.
TO DELETE THE ITEM AT INDEX 1, THE
NUMBER OF ITEMS MOVED IS 1.
Queues
97
EXERCISE: SUPPOSE, FOR SOME deque
CONTAINER, BLOCK SIZE = 10 AND
THE FIRST ITEM IS AT INDEX 7 IN
BLOCK 0. DETERMINE THE BLOCK
AND OFFSET FOR INDEX 31.
Queues
98
Priority Queue
A Special form of queue from which items are
removed according to their designated priority and
not the order in which they entered.
Job # 1
M anager
Job # 4
Supervisor
Job # 2
President
Job # 3
Clerk
Items entered the queue in sequential order but will be
removed in the order #2, #1, #4, #3.
Queues
99
CLASS priority_queue
Constructor
<queue>
priority_queue();
Create an empty priority queue. Type T must
implement the operator <.
CLASS priority_queue
Operations
<queue>
bool empty() const;
Check whether the priority queue is empty. Return true
if it is empty, and false otherwise. Create
void pop();
Remove the item of highest priority from the queue.
Precondition: The priority queue is not empty.
Postcondition: The priority queue has 1 less element
Queues
100
CLASS priority_queue
Operations
<queue>
void push(const T& item);
Insert the argument item into the priority queue.
Postcondition: The priority queue contains a new
element.
int size() const;
Return the number of items in the priority queue.
T& top();
Return a reference to the item having the highest
priority.
Precondition: The priority queue is not empty.
const T& top();
Constant version of top().
Queues
101
PQ Implementation

How would you implement a priority queue?
Queues
102
Summary Slide 1
§- Queue
- A first-come-first-served data structure.
§- Insertion operations (push()) occur at the back of the
sequence
§- deletion operations (pop()) occur at the front of the
sequence.
Queues
10
103
3
Summary Slide 2
§- The radix sort algorithm
- Orders an integer vector by using queues (bins).
- This sorting technique has running time O(n) but
has only specialized applications.
- The more general in-place O(n log2n) sorting
algorithms are preferable in most cases.
Queues
10
104
4
Summary Slide 3
§- Implementing a queue with a fixed-size
array
- Indices qfront and qback move circularly around
the array.
- Gives O(1) time push() and pop() operations with
no wasted space in the array.
Queues
10
105
5
Summary Slide 4
§- Priority queue
- Pop() returns the highest priority item (largest or
smallest).
- Normally implemented by a heap, which is
discussed later in the class.
- The push() and pop() operations have running
time O(log2n)
Queues
10
106
6