1

What is a Queue?

• 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.

Queues

2

Queues: Application Level

3

• 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.

Application of Queue and Stack

4

• 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

Queues: implementation level

5

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

Array-Based Implementation

6

private:

ItemType* items; // Dynamically allocated array

int maxQue;

// Whatever else we need

};

Implementation level

Array-Based Implementation

7

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?

Array-Based Implementation

8

Another data structure: An array where the front floats.

What happens if we add X, Y, and Z?

Array-Based Implementation

9

Let the queue wrap around in the array; i.e. treat the array as a circular structure.

Array-Based Implementation

10

Empty Queue

Full Queue

How can we tell the difference?

(a) Initial conditions

front = 2

rear = 2

(b) queue.Dequeue(item)

front = 3

rear = 2

A

[0] [1] [2] [3] [4]

[0] [1] [2] [3] [4]

Array-Based Implementation

11

Reserve the slot (not used) before front item.

front is the index of the slot before front item.

Empty Queue

Full Queue

12

DYNAMIC ARRAY IMPLEMENTATION

QueType

~QueType

Enqueue

Dequeue . . .

class QueType

Private Data:

front 1

rear 4

maxQue 5

items‘C’ ‘X’ ‘J’

items [0] [1] [2] [3] [4]

RE

SE

RV

ED

Array-Based Implementation

13

private: int front; int rear; int maxQue;

ItemType* items;};

Completeimplementation level

Array-Based Implementation

14

//returns true if the queue is emptybool QueueType::IsEmpty( ){ return ( rear == front );}

//returns true if the queue is fullbool QueueType::IsFull( ){ return ( (rear + 1) % maxQue == front )}

Array-Based Implementation

15

//Pre: the queue is not full//Post: newItem is at the rear of the queuevoid QueueType::Enqueue(ItemType newItem){ rear = (rear + 1) % maxQue; items[rear] = newItem; }

Array-Based Implementation

16

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

Array-Based Implementation

17

QueueType::QueueType( int max) { maxQue = max + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue];}

QueueType::QueueType( ) { maxQue = 500 + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue];}

Why is the array declaredmax + 1?

Counted Queue*

18

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?

Counted Queue*

19

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

Counted Queue*

20

Counted Queue*

21

void CountedQueueType::Enqueue(ItemType newItem)

{

try

{

QueueType::Enqueue(newItem);

length++;

}

catch(FullQueue)

{ throw FullQueue();}

}

Why must the call to Enqueue beembedded within a try/catch statement?

What is this?

Counted Queue*

22

Does the derived class have access to the base class’s private data members in C++?

Linked Implementation

23

Data structure for linked queue

What data members are needed?

Linked Implementation

24

Enqueue(newItem)Set newNode to the address of newly allocated nodeSet Info(newNode) to newItemSet Next(newNode) to NULLSet Next(rear) to newNodeIf queue is empty

Set front to newNodeelse

Set Next(rear) to newNode

Linked Implementation

25

Dequeue(item)Set tempPtr to frontSet item to Info(front)Set front to Next(front)if queue is now empty

Set rear to NULLDeallocate Node(tempPtr)

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

Storage Requirements

27 What does this table tell you?

Big-O Comparison (Queue)

Time Array-Based Implementation

Linked Implementation

Class constructor

Class destructor

O(1)

O(1)

O(1)

O(n)

IsFull()

IsEmpty()

O(1)

O(1)

O(1)

O(1)

Enqueue()

Dequeue()

O(1)

O(1)

O(1)

O(1)

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

}

template<class ItemType>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}

. . .

template<class ItemType>bool QueType<ItemType>::IsFull( )

{ // WRAP AROUNDreturn ( (rear + 1) % maxQue == front )

} 31

32

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;

};

3333

// Member function definitions for class CountedQue

template<class ItemType>

CountedQueType<ItemType>::CountedQueType( ) : QueType<ItemType>( )

{

length = 0 ;

}

template<class ItemType>

int CountedQueType<ItemType>::LengthIs( ) const

{

return length ;

}

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 );}

template<class ItemType>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>

QueType

~QueType

Enqueue

Dequeue . . .

Private Data:

qFront

qRear

‘C’ ‘Z’ ‘T’

36

// DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE

#include "ItemType.h" // for ItemType

template<class ItemType>class QueType {public:

QueType( ); // CONSTRUCTOR~QueType( ) ; // DESTRUCTORbool 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;

}

template<class ItemType>

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