1. What is a Queue? A queue is a FIFO “first in, first out” structure.
Logical (or ADT) level: A queue is an ordered group of homogeneous items (elements), in which new elements are added at one end (the rear), and elements are removed from the other end (the front).
A queue is a FIFO “first in, first out” structure.

2. Queues 2 2

3. Queues: Application Level
For what type of problems would queues be useful?
Print server
maintains a queue of print jobs.
Disk driver
maintains a queue of disk input/output requests.
Scheduler (e.g., in an operating system)
maintains a queue of processes awaiting a slice of machine time. 3 3

4. Application of Queue and Stack
Palindromes: words or phrases that read the same in both directions, e.g. EYE, RACECAR, MADAM I'M ADAM, and :
Testing if a given word or phrase is a palindrome:
Scan the string character by character, and store each character into a stack(push) and queue(enqueue)
After all characters have been processed, repeatedly pop a character from the stack, and deque a character from the queue, and compare them. Not match=>not a palindrome
If finished comparing with no mismatches => a palindrome 4 4

5. Queues: implementation level
class QueueType { public: QueueType(int max); QueueType(); ~QueueType(); bool IsEmpty() const; bool IsFull() const; void Enqueue(ItemType item); //add newItem to the rear of the queue. void Dequeue(ItemType& item); //remove front item from queue 5 5

6. Array-Based Implementation
private:
ItemType* items; // Dynamically allocated array
int maxQue;
// Whatever else we need };
Implementation level 6 6

7. Array-Based Implementation
An array with the front of the queue fixed in the first position.
Enqueue A, B, C, D
Dequeue
Shift elements up by 1
What’s the problem with this design? 7 7

8. Array-Based Implementation
Another data structure: An array where the front floats.
What happens if we add X, Y, and Z? 8 8

9. Array-Based Implementation
Let the queue wrap around in the array; i.e. treat the array as a circular structure. 9 9

10. Array-Based Implementation
(a) Initial conditions
front = 2
rear = 2
(b) queue.Dequeue(item)
front = 3 A
[0] [1] [2] [3] [4]
Empty Queue
Full Queue
How can we tell the difference? 10

11. Array-Based Implementation
Reserve the slot (not used) before front item.
front is the index of the slot before front item.
Empty Queue
Full Queue 11 11

12. DYNAMIC ARRAY IMPLEMENTATION
class QueType
QueType
Private Data:
front
rear
maxQue 5
items
~QueType
Enqueue
‘C’ ‘X’ ‘J’
RESERVED
Dequeue .
items [0] [1] [2] [3] [4] 12 12

13. Array-Based Implementation
private:
int front;
int rear;
int maxQue;
ItemType* items; };
Complete
implementation level 13 13

14. Array-Based Implementation
//returns true if the queue is empty bool QueueType::IsEmpty( ) { return ( rear == front ); } //returns true if the queue is full bool QueueType::IsFull( ) return ( (rear + 1) % maxQue == front ) 14 14

15. Array-Based Implementation
//Pre: the queue is not full
//Post: newItem is at the rear of the queue
void QueueType::Enqueue(ItemType newItem) {
rear = (rear + 1) % maxQue;
items[rear] = newItem; } 15 15

16. Array-Based Implementation
//pre: the queue is not empty
//post: the front of the queue has been removed
// and a copy returned in item
void QueueType::Dequeue(ItemType& item) {
front = (front + 1) % maxQue;
item = items[front]; } 16 16

17. Array-Based Implementation
QueueType::QueueType( int max) {
maxQue = max + 1;
front = maxQue - 1;
rear = maxQue - 1;
items = new ItemType[maxQue]; }
QueueType::QueueType( )
{ maxQue = ;
Why is the array declared
max + 1? 17 17

18. Counted Queue* Counted Queue
A queue that has an additional function GetLength that returns the number of items in the queue.
The CountedQueType class will inherit (extend) the QueType class.
What functions must be defined in class CountedQueType? 18 18

19. Counted Queue* class CountedQueueType : public QueueType { public:
void Enqueue(ItemType newItem);
void Dequeue(ItemType& item);
int GetLength( ) const;
private:
int length; }; 19 19

20. Counted Queue* 20 20

21. Counted Queue* What is this? Why must the call to Enqueue be
void CountedQueueType::Enqueue(ItemType newItem) {
try
QueueType::Enqueue(newItem);
length++; }
catch(FullQueue)
{ throw FullQueue();}
What is this?
Why must the call to Enqueue be
embedded within a try/catch statement? 21 21

22. Counted Queue*
Does the derived class have access to the base class’s private data members in C++? 22 22

23. Linked Implementation
Data structure for linked queue
What data members are needed? 23 23

24. Linked Implementation
Enqueue(newItem)
Set newNode to the address of newly allocated node
Set Info(newNode) to newItem
Set Next(newNode) to NULL
Set Next(rear) to newNode
If queue is empty
Set front to newNode
else 24 24

25. Linked Implementation
Dequeue(item)
Set tempPtr to front
Set item to Info(front)
Set front to Next(front)
if queue is now empty
Set rear to NULL
Deallocate Node(tempPtr) 25 25

26. Circular Linked Queue Make the linked queue circular:
Make the next member of rear node point to the front node of the queue
Maintain a single pointer: rear
Accessing front node is a constant time operation:
rear->next 26

27. What does this table tell you?
Storage Requirements
What does this table tell you? 27 27

28. Big-O Comparison (Queue)
Time
Array-Based Implementation
Linked Implementation
Class constructor
Class destructor
O(1)
O(n)
IsFull()
IsEmpty()
Enqueue()
Dequeue() 28 28

29. //--------------------------------------------------------
// CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE
#include "ItemType.h" // for ItemType
template<class ItemType>
class QueType {
public:
QueType( );
QueType( int max ); // PARAMETERIZED CONSTRUCTOR
~QueType( ); // DESTRUCTOR
bool IsFull( ) const;
void Enqueue( ItemType item );
void Dequeue( ItemType& item );
private:
int front;
int rear;
int maxQue;
ItemType* items; // DYNAMIC ARRAY IMPLEMENTATION }; 29

30. //--------------------------------------------------------
// CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d
template<class ItemType>
QueType<ItemType>::QueType( int max ) // PARAMETERIZED {
maxQue = max + 1;
front = maxQue - 1;
rear = maxQue - 1;
items = new ItemType[maxQue]; // dynamically allocates }
bool QueType<ItemType>::IsEmpty( )
return ( rear == front ) 30

31. //--------------------------------------------------------
// CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d
template<class ItemType>
QueType<ItemType>::~QueType( ) {
delete [ ] items; // deallocates array } .
bool QueType<ItemType>::IsFull( )
{ // WRAP AROUND
return ( (rear + 1) % maxQue == front ) 31

32. // DERIVED CLASS CountedQueType FROM BASE CLASS QueType
ALL PUBLIC MEMBERS OF QueType CAN BE INVOKED FOR OBJECTS OF TYPE CountedQueType
// DERIVED CLASS CountedQueType FROM BASE CLASS QueType
template<class ItemType>
class CountedQueType : public QueType<ItemType> {
public:
CountedQueType( );
void Enqueue( ItemType newItem );
void Dequeue( ItemType& item );
int LengthIs( ) const;
// Returns number of items on the counted queue.
private:
int length; };

33. // Member function definitions for class CountedQue
template<class ItemType>
CountedQueType<ItemType>::CountedQueType( ) : QueType<ItemType>( ) {
length = 0 ; }
int CountedQueType<ItemType>::LengthIs( ) const
return length ; 33

34. template<class ItemType>
void CountedQueType<ItemType>::Enqueue( ItemType newItem )
// Adds newItem to the rear of the queue.
// Increments length. {
length++;
QueType<ItemType>::Enqueue( newItem ); }
void CountedQueType<ItemType>::Dequeue(ItemType& item )
// Removes item from the rear of the queue.
// Decrements length.
length--;
QueType<ItemType>::Dequeue( item );

35. class QueType<char>
Private Data:
qFront
qRear
‘C’
‘Z’ ‘T’
~QueType
Enqueue
Dequeue .

36. // DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE
#include "ItemType.h" // for ItemType
template<class ItemType>
class QueType {
public:
QueType( ); // CONSTRUCTOR
~QueType( ) ; // DESTRUCTOR
bool IsEmpty( ) const;
bool IsFull( ) const;
void Enqueue( ItemType item );
void Dequeue( ItemType& item );
void MakeEmpty( );
private:
NodeType<ItemType>* qFront;
NodeType<ItemType>* qRear; }; 36

37. // DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE continued
// member function definitions for class QueType
template<class ItemType>
QueType<ItemType>::QueType( ) // CONSTRUCTOR {
qFront = NULL;
qRear = NULL; }
bool QueType<ItemType>::IsEmpty( ) const
return ( qFront == NULL ) 37

38. template<class ItemType>
void QueType<ItemType>::Enqueue( ItemType newItem )
// Adds newItem to the rear of the queue.
// Pre: Queue has been initialized.
// Queue is not full.
// Post: newItem is at rear of queue. {
NodeType<ItemType>* ptr;
ptr = new NodeType<ItemType>;
ptr->info = newItem;
ptr->next = NULL;
if ( qRear == NULL )
qFront = ptr;
else
qRear->next = ptr;
qRear = ptr; } 38

39. template<class ItemType>
void QueType<ItemType>::Dequeue( ItemType& item )
// Removes element from from front of queue
// and returns it in item.
// Pre: Queue has been initialized.
// Queue is not empty.
// Post: Front element has been removed from queue.
// item is a copy of removed element. {
NodeType<ItemType>* tempPtr;
tempPtr = qFront;
item = qFront->info;
qFront = qFront->next;
if ( qFront == NULL )
qRear = NULL;
delete tempPtr; } 39