Presentation is loading. Please wait.

Presentation is loading. Please wait.

What is a Queue? A queue is a FIFO “first in, first out” structure.

Similar presentations


Presentation on theme: "What is a Queue? A queue is a FIFO “first in, first out” structure."— Presentation transcript:

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


Download ppt "What is a Queue? A queue is a FIFO “first in, first out” structure."

Similar presentations


Ads by Google