Presentation is loading. Please wait.

Presentation is loading. Please wait.

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.

Similar presentations


Presentation on theme: "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."— Presentation transcript:

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

2 Queues 2

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

4 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

5 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

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

7 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?

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

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

10 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]

11 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 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] RESERVED

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

14 Array-Based Implementation 14 //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 ) }

15 Array-Based Implementation 15 //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; }

16 Array-Based Implementation 16 //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]; }

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

18 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 ?

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

20 Counted Queue* 20

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

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

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

24 Linked Implementation 24 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 Set Next(rear) to newNode

25 Linked Implementation 25 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)

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 Storage Requirements 27 What does this table tell you?

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

29 29 // // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE #include "ItemType.h" // for ItemType template 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 30 // // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d // template QueType ::QueType( int max ) // PARAMETERIZED { maxQue = max + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue]; // dynamically allocates } template bool QueType ::IsEmpty( ) { return ( rear == front ) } 30

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

32 32 ALL PUBLIC MEMBERS OF QueType CAN BE INVOKED FOR OBJECTS OF TYPE CountedQueType // DERIVED CLASS CountedQueType FROM BASE CLASS QueType template class CountedQueType : public QueType { 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 33 // Member function definitions for class CountedQue template CountedQueType ::CountedQueType( ) : QueType ( ) { length = 0 ; } template int CountedQueType ::LengthIs( ) const { return length ; }

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

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

36 36 // DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE #include "ItemType.h" // for ItemType template 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 * qFront; NodeType * qRear; }; 36

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

38 38 template void QueType ::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 * ptr; ptr = new NodeType ; ptr->info = newItem; ptr->next = NULL; if ( qRear == NULL ) qFront = ptr; else qRear->next = ptr; qRear = ptr; } 38

39 39 template void QueType ::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 * tempPtr; tempPtr = qFront; item = qFront->info; qFront = qFront->next; if ( qFront == NULL ) qRear = NULL; delete tempPtr; } 39


Download ppt "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."

Similar presentations


Ads by Google