1 / 52

Data Structures Using C++ 2E

Learn how to implement a queue data structure using arrays in C++, including operations and solutions for overflow and circular arrays.

tbax
Download Presentation

Data Structures Using C++ 2E

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Data Structures Using C++ 2E Chapter 8 Queues Edited by Malak Abdullah Jordan University of Science and Technology

  2. Introduction Queue data structure Elements added at one end (rear), deleted from other end (front) First In First Out (FIFO) Middle elements inaccessible

  3. Queue Operations Two key operations addQueue deleteQueue Additional operations initializeQueue, isEmptyQueue, isFullQueue, front, back queueFront, queueRear pointers Keep track of front and rear See code on pages 453-454

  4. Implementation of Queues as Arrays Four member variables Array to store queue elements Variables queueFront, queueRear Variable maxQueueSize Using queueFront, queueRear to access queue elements queueFront:first queue element index queueRear:last queue element index queueFront changes after each deleteQueue operation queueRear changes after each addQueue operation

  5. Empty Queue 0 1 2 3 4 5 6 ....... 19 list maxSize 20 front 0 19 rear 0 count

  6. addQueue(‘R’) 0 1 2 3 4 5 6 ....... 19 list maxSize R 20 front 0 0 rear 1 count

  7. addQueue(‘T’) 0 1 2 3 4 5 6 ....... 19 list maxSize R T 20 front 0 1 rear 2 count

  8. addQueue(‘P’) 0 1 2 3 4 5 6 ....... 19 list maxSize R T P 20 front 0 2 rear 3 count

  9. deleteQueue() 0 1 2 3 4 5 6 ....... 19 list maxSize R T P 20 front 1 2 rear 2 count

  10. addQueue(‘M’) 0 1 2 3 4 5 6 ....... 19 list maxSize R T P M 20 front 1 3 rear 3 count

  11. Implementation of Queues as Arrays(cont’d.) Execute operation addQueue(Queue,'A'); Execute addQueue(Queue,'B'); addQueue(Queue,'C'); Execute deleteQueue(); Data Structures Using C++ 2E

  12. FIGURE 8-1 Queue after the first addQueue operation FIGURE 8-2 Queue after two more addQueue operations FIGURE 8-3 Queue after the deleteQueue operation Data Structures Using C++ 2E

  13. Implementation of Queues as Arrays (cont’d.) Consider the sequence of operations: AAADADADADADADADA... Eventually index queueRear points to last array position Looks like a full queue Reality: queue has two or three elements, array empty in the front FIGURE 8-4 Queue after the sequence of operations AAADADADADADA... Data Structures Using C++ 2E

  14. Implementation of Queues as Arrays (cont’d.) First solution Upon queue overflow to the rear Check value of queueFront If room in front: slide all queue elements toward first array position Works if queue size very small Second solution: assume circular array FIGURE 8-5 Circular queue Data Structures Using C++ 2E

  15. We need to add ‘B’ !!???!! 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P M S A F D 20 front 16 19 rear It seems full but it is not 4 count First Solution 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize S A F D B 20 front 0 4 rear 5 count Imagine 1000000 elements????

  16. We need to add ‘B’ !!???!! 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P M S A F D 20 front 16 19 rear It seems full but it is not 4 count Second Solution 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize B T P M S A F D 20 front 16 1 0 0 rear 19 5 count 18

  17. How To implement this solution Second Solution 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P M S A F D 20 front 16 1 0 19 rear 19 5 count 18 rear= (rear +1 ) % 20 List [rear] =‘B’ count++; If (rear ==19 && count < 20) then { rear= 0; } list(rear)= ‘B’ count++;

  18. Implementation of Queues as Arrays(cont’d.) queueRear = (queueRear + 1) % maxQueueSize; Advances queueRear (queueFront) to next array position FIGURE 8-6 Queue before and after the add operation Data Structures Using C++ 2E

  19. Implementation of Queues as Arrays(cont’d.) If queueRear < maxQueueSize – 1 queueRear + 1 <= maxQueueSize – 1 (queueRear + 1) % maxQueueSize = queueRear + 1 If queueRear == maxQueueSize – 1 queueRear + 1 == maxQueueSize (queueRear + 1) % maxQueueSize = 0 queueRear set to zero First array position f r 0 f r Data Structures Using C++ 2E

  20. Implementation of Queues as Arrays (cont’d.) Two cases with identical queueFront, queueRear values Figure 8-7(b) represents an empty queue Figure 8-8(b) represents a full queue FIGURE 8-7 Queue before and after the delete operation FIGURE 8-8 Queue before and after the add operation Data Structures Using C++ 2E

  21. See More 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P M 20 front 3 3 rear 1 count deleteQueue(); 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P M 20 front 4 As You see (empty Queue) front= rear +1 3 rear 0 count

  22. See More 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T F T A S D Q U 20 M front 4 2 rear 19 count addQueue(‘P’); 0 1 2 3 4 5 6 ....... 16 17 18 19 list maxSize R T P T A S D Q U 20 M front 4 3 rear As You see (Full Queue) front= rear +1 20 count

  23. Implementation of Queues as Arrays(cont’d.) First solution: use variable count Incremented when new element added Decremented when element removed Functions initializeQueue, destroyQueue initialize count to zero Data Structures Using C++ 2E

  24. Implementation of Queues as Arrays(cont’d.) Second solution queueFront indicates index of array position preceding first element of the queue Assume queueRear indicates index of last element Empty queue if queueFront == queueRear Slot indicated by index queueFront is reserved Queue is full If next available space represents special reserved slot Data Structures Using C++ 2E

  25. Implementation of Queues as Arrays(cont’d.) See code on pages 459-460 Uses first solution FIGURE 8-9 Array to store the queue elements with a reserved slot Data Structures Using C++ 2E

  26. Empty Queue and Full Queue Empty queue If count == 0 Full queue If count == maxQueueSize Data Structures Using C++ 2E

  27. Initialize Queue Initializes queue to empty state First element added at the first array position Initialize queueFront to zero, queueRear to maxQueueSize - one, count to zero FIGURE 8-10 Empty queue Data Structures Using C++ 2E

  28. Front Returns first queue element If the queue nonempty Element indicated by index queueFront returned Otherwise Program terminates Data Structures Using C++ 2E

  29. Back Returns last queue element If queue nonempty Returns element indicated by index queueRear Otherwise Program terminates Data Structures Using C++ 2E

  30. Add Queue Data Structures Using C++ 2E

  31. Delete Queue Data Structures Using C++ 2E

  32. Constructors and Destructors Data Structures Using C++ 2E

  33. Constructors and Destructors (cont’d.) Array storing queue elements Created dynamically When queue object goes out of scope Destructor deallocates memory occupied by the array storing queue elements Data Structures Using C++ 2E

  34. Linked Implementation of Queues Array implementation issues Fixed array size Finite number of queue elements Requires special array treatment with the values of the indices queueFront, queueRear Linked implementation of a queue Simplifies special cases of the array implementation Queue never full See code on pages 464-465 Data Structures Using C++ 2E

  35. Linked Queue front rear front 5 22 16 rear

  36. addQueu(9) front 5 22 16 rear nodeType *N; Ninfo= 9; Nlink=NULL; rearlink=N; rear= N; front 5 22 16 9 rear

  37. deleteQueu() front 5 22 16 rear nodeType *p; p= front; front= frontlink; Delete p; front 22 16 rear

  38. Empty and Full Queue Empty queue if queueFront is NULL Memory allocated dynamically Queue never full Function implementing isFullQueue operation returns the value false Data Structures Using C++ 2E

  39. Initialize Queue Initializes queue to an empty state Empty if no elements in the queue Data Structures Using C++ 2E

  40. addQueue, front, back, and deleteQueue Operations addQueue operation adds a new element at end of the queue Access the pointer queueRear Data Structures Using C++ 2E

  41. addQueue, front, back, and deleteQueue Operations (cont’d.) If queue nonempty Operation front returns first element Element indicated queueFront returned If queue empty: front terminates the program Data Structures Using C++ 2E

  42. addQueue, front, back, and deleteQueue Operations (cont’d.) If queue nonempty Operation back returns last element Element indicated by queueRear returned If queue empty: back terminates the program Data Structures Using C++ 2E

  43. addQueue, front, back, and deleteQueue Operations (cont’d.) If queue nonempty Operation deleteQueue removes first element Access pointer queueFront Data Structures Using C++ 2E Edited by Malak Abdullah Jordan University of Science and Technology

  44. addQueue, front, back, and deleteQueue Operations (cont’d.) Default constructor When queue object goes out of scope Destructor destroys the queue Deallocates memory occupied by the queue elements Function definition similar to function initializeQueue Data Structures Using C++ 2E

  45. Queue Derived from the class unorderedLinkedListType Linked queue implementation Similar to forward manner linked list implementation Similar operations add Queue, insertFirst initializeQueue , initializeList isEmptyQueue, isEmptyList deleteQueue operation implemented as before Same pointers queueFront and first, queueRear and last Data Structures Using C++ 2E

  46. Queue Derived from the class unorderedLinkedListType (cont’d.) Linked queue implementation (cont’d.) Can derive the class to implement the queue from the class linkedListType class linkedListType An abstract Does not implement all operations class unorderedLinkedListType Derived from class linkedListType Provides definitions of the abstract functions of the class linkedListType Data Structures Using C++ 2E

  47. STL class queue (Queue Container Adapter) Standard Template Library (STL) Provides a class to implement queues in a program Queue Name of class defining the queue Name of header defining class queue Data Structures Using C++ 2E

  48. STL class queue(cont’d.) Queue container class Provides relational operators comparing two queues See Example 8-2 TABLE 8-1 Operations on a queue object Data Structures Using C++ 2E

  49. Priority Queues Queue structure ensures items processed in the order received Priority queues Customers (jobs) with higher priority pushed to the front of the queue Implementation Ordinary linked list Keeps items in order from the highest to lowest priority Treelike structure Very effective Chapter 10 Data Structures Using C++ 2E

  50. Application of Queues: Simulation Queuing systems Computer simulations Queues represent the basic data structure Queues of objects Waiting to be served by various servers Consist of servers and queues of objects waiting to be served Data Structures Using C++ 2E

More Related