Queues - PowerPoint PPT Presentation

Title: Queues


1
Chapter 7 Queues
The queue abstract data type is essentially a
list using the FIFO (first-in-first-out) policy
for adding and removing elements.
The principal queue operations

• Create an empty queue.

• Copy an existing queue.

• Destroy a queue.

• Determine whether a queue is empty.

• Add a new element to a queue.

• Remove the least recently added element from a
  queue.

2
Queue Implementation Alternatives

• An Array Implementation
• Positives
• Avoids pointers (uses front rear indices)
• Negatives
• Wraparound is needed to avoid false overflows
• Size must be declared in advance

• A Linked List Implementation
• Positives
• Dynamically allocates exactly the right amount of
  memory
• Wraparound problem is circumvented
• Negatives
• Our friendly neighborhood pointers

3
Array Implementation of Queue
// Class implementation file queue.cpp // Array
implementation of the queue ADT. include
"queue.h" include ltcassertgt using namespace
std // Default constructor Make empty queue
// queue queue() front 0 rear
MAX_QUEUE_SIZE 1 length 0 // Copy
constructor Make copy of queue. // queue
queue(const queue q) int index front
q.front rear q.rear length q.length
for (int i 0 i lt length i)
index (i q.front) MAX_QUEUE_SIZE
listindex q.listindex
// Class declaration file queue.h // Array
implementation of the queue ADT. ifndef
QUEUE_H include ltiostreamgt using namespace
std typedef int elementType const
MAX_QUEUE_SIZE 200 class queue public
// Class constructors queue()
queue(const queue q) // Member functions
bool isEmpty() void enqueue(const
elementType item) elementType dequeue()
protected // Data members int front,
rear, length elementType listMAX_QUEUE_SIZE
// Member function bool
isFull() define QUEUE_H endif
4
// isEmpty function signals if this is empty
queue. // bool queue isEmpty() return
(length 0) // Enqueue function inserts a
new item into the // // rear of queue this (if
there's enough room). // void queue
enqueue(const elementType item)
assert(!isFull()) rear (rear1)
MAX_QUEUE_SIZE listrear item
length // Dequeue function remove the item
at the // // front of queue this (if there's
one there). // elementType queue dequeue()
elementType item assert(!isEmpty()) item
listfront front (front1)
MAX_QUEUE_SIZE length-- return item //
isFull function returns boolean value indicating
// // if this is a full queue (w.r.t. the
array). // bool queue isFull() return
(length MAX_QUEUE_SIZE)
Insert from the rear (with wraparound)
Remove from the front (with wraparound)
5
Linked List Implementation of Queue
// Class declaration file Queue.h // Linked List
implementation of queue ADT. ifndef
QUEUE_H include "LinkedList.h" include
ltiostreamgt using namespace std class queue
protected LinkedList public // Class
constructors queue() queue(const queue
q) // Member functions bool isEmpty()
void enqueue(const elementType item)
elementType dequeue() protected // Data
members nodePtr tail define
QUEUE_H endif
// Class implementation file Queue.cpp // Linked
List implementation of the queue ADT. include
"queue.h" include ltcassertgt include
ltcstdlibgtusing namespace std// Default
constructor Makes an empty queue //queue
queue() LinkedList() tail NULL
The queue class inherits from the LinkedList
class, so all LinkedList members are accessible
to any queue. With its protected access
specifier, the public and protected members of
LinkedList are considered protected in the queue
class.
Lets assume that the getNode and head members in
LinkedList were declared protected, not
private! Lets also assume that the elementType
typedef occurred in the LinkedList definition!
6
// Copy constructor Makes a deep // // copy of
the this queue. // queue queue(const
queue q) nodePtr copyPreviousPtr, copyPtr,
origPtr if (q.head NULL) tail head
NULL else head
getNode(q.head-gtitem) copyPreviousPtr
head origPtr q.head-gtnext while
(origPtr ! NULL) copyPtr
getNode(origPtr-gtitem)
copyPreviousPtr-gtnext copyPtr
copyPreviousPtr copyPtr origPtr
origPtr-gtnext tail
copyPreviousPtr // isEmpty function
Determines // // if the this queue is empty.
// bool queue isEmpty() return (head
NULL)
// Enqueue function Inserts item // // into
the back of the this queue. // void queue
enqueue(const elementType elt) nodePtr
newPtr getNode(elt) assert (newPtr !
NULL) if (head NULL) head tail
newPtr else tail-gtnext newPtr
tail newPtr // Dequeue function
Removes item // // from the front of the this
queue // // (assuming such an item exists).
// elementType queue dequeue() elementType
elt nodePtr oldHead assert(head !
NULL) oldHead head elt head-gtitem
head head-gtnext if (head NULL)
tail NULL delete oldHead return elt
7
Example Queue Application
// Program file carwash.cpp
// // This program simulates the operation of a
// // car wash over 10 hours (600 minutes) of
// // operation. The variables timeForWash and
// // probOfArrival represent the time it takes
// // to run one car through the car wash and
// // the probability that a car arrives in any
// // given minute.
// include ltiostreamgt include
ltiomanipgt include ltctimegt include
ltcstdlibgtinclude "queue.h" using namespace
std float random() void initializeRandomSeed()
// The main function simulates the arrival of
// // 600 cars at the car wash, queueing those
// // which have to wait, and keeping a running
// // tally of how long the cars are queued up.
// void main() int timeForWash, minute,
timeEnteredQueue, carsWashed,
totalQueueMin, timeLeftOnCar float
probOfArrival queue carQueue
cout ltlt "Enter time (in minutes) ltlt "
to wash one car " cin gtgt timeForWash cout
ltlt "Enter probability of " ltlt "arrival in
any minute " cin gtgt probOfArrival
carsWashed 0 totalQueueMin 0
timeLeftOnCar 0 for (minute 1 minute lt
600 minute) if (random() lt
probOfArrival) carQueue.enqueue(minute)
if ((timeLeftOnCar 0)
!carQueue.isEmpty()) timeEnteredQueue
carQueue.dequeue() totalQueueMin
(minute
timeEnteredQueue) carsWashed
timeLeftOnCar timeForWash if
(timeLeftOnCar ! 0) timeLeftOnCar--
8
cout ltlt endl ltlt carsWashed ltlt " cars were
washed" ltlt endl cout.setf(iosfixed) cout
ltlt setprecision(2) cout ltlt "Average wait in
queue " ltlt float(totalQueueMin)/carsWashed
ltlt " minutes." ltlt endl ltlt endl // Function
random produces random floating-point number
between 0 and 1. // float random() //
Generate random number seed the first time the
function is called. static int iteration 0
iteration if (iteration 1)
initializeRandomSeed() return (float(rand()) /
RAND_MAX) // Function initializeRandomSeed
uses the time.h library function time() to seed
// // the stdlib.h library function rand() via
the stdlib.h library function srand(). // void
initializeRandomSeed() // Time-elapsed value,
used to seed the random number generator. long
int randomNumberSeed time(randomNumberSeed)
srand(randomNumberSeed) return