1. Chapter 7 Queues

2. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-2 Chapter Objectives Examine queue processing Define a queue abstract data type Demonstrate how a queue can be used to solve problems Examine various queue implementations Compare queue implementations

3. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-3 Queues A queue is a collection whose elements are added on one end and removed from another Therefore a queue is processed in a FIFO fashion: first in, first out Elements are removed in the same order they arrive Any waiting line is a queue: the check out line at a grocery store the cars at a stop light an assembly line

4. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-4 Queues A queue is usually depicted horizontally One end of the queue is the rear (or tail), where elements are added The other end is the front (or head), from which elements are removed Unlike a stack, which operates on one end of the collection, a queue operates on both ends

5. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-5 figure 7.1 A conceptual view of a queue

6. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-6 Queue Operations The term enqueue is used to refer to the process of adding an element to a queue Likewise, dequeue is the process of removing an element Like a stack, a pure queue does not allow the user to access the elements in the middle of the queue We include a toString method for convenience

7. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-7 figure 7.2 The operations on a queue See QueueADT.java (page 180)QueueADT.java

8. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-8 figure 7.3 The QueueADT interface in UML

9. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-9 Coded Messages Let's use a queue to help us encode and decode messages A Ceasar cipher encodes a message by shifting each letter in a message by a constant amount k If k is 5, A becomes F, B becomes G, etc. However, this is fairly easy to break An improvement can be made by changing how much a letter is shifted depending on where the letter is in the message

10. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-10 Coded Messages A repeating key is a series of integers that determine how much each character is shifted For example, consider the repeating key 3 1 7 4 2 5 The first character in the message is shifted 3, the next 1, the next 7, and so on When the key is exhausted, we just start over at the beginning of the key

11. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-11 figure 7.4 An encoded message using a repeating key

12. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-12 Coded Messages We'll use a queue to store the values of the key We'll dequeue a value when needed After using a key value, we then enqueue it back onto the end of the queue That way the queue represents the constantly cycling values in the key See Codes.java (page 183)Codes.java

13. figure 7.5 UML description of the Codes program

14. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-14 Ticket Counter Simulation Now let's use a queue to simulate the waiting line at a movie theatre The goal is to determine how many cashiers are needed to keep the wait time below 7 minutes We'll assume: customers arrive on average every 15 seconds processing a request takes two minutes once a customer reaches a cashier See Customer.java (page 186)Customer.java See TicketCounter.java (page 188)TicketCounter.java

15. figure 7.6 UML description of the TicketCounter program

16. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-16 figure 7.7 The results of the ticket counter simulation

17. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-17 Radix Sort Let's look at one more use of queues A radix sort uses queues to order a set of values A queue is created for each possible value in the sort key For example, if the sort key was a lowercase alphabetic string, there would be 26 queues If the sort key was a decimal integer, there would be 10 queues corresponding to the digits 0 through 9

18. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-18 Radix Sort Each pass through the sort examines a particular position in the sort value The element is put on the queue corresponding to that position's value Processing starts with the least significant position (1s) to the most significant position The following example uses integers with only the digits 0 through 5

19. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-19 figure 7.8 A radix sort of ten three-digit numbers

20. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-20 Radix Sort Now let's look at a program that implements a radix sort It maintains an array of 10 queues, one for each digit (0-9) See RadixSort.java (page 194)RadixSort.java

21. figure 7.9 UML description of the RadixSort program

22. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-22 The LinkedQueue Class Like a stack, a queue can be implemented using an underlying array or a linked list A linked version can use the LinearNode class yet again In addition to keeping a reference to the beginning of the list, we will keep a second reference to the end An integer count will keep track of the number of elements in the queue

23. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-23 figure 7.10 A linked implementation of a queue

24. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-24 The enqueue Operation //----------------------------------------------------------------- // Adds the specified element to the rear of the queue. //----------------------------------------------------------------- public void enqueue (Object element) { LinearNode temp = new LinearNode (element); if (isEmpty()) front = node; else rear.setNext (node); rear = node; count++; }

25. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-25 figure 7.11 The queue after adding element E

26. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-26 The dequeue Operation //----------------------------------------------------------------- // Removes the element at the front of the queue and returns a // reference to it. Throws an EmptyCollectionException if the // queue is empty. //----------------------------------------------------------------- public Object dequeue () throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); Object result = front.getElement(); front = front.getNext(); count--; if (isEmpty()) rear = null; return result; }

27. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-27 figure 7.12 The queue after a dequeue operation

28. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-28 The ArrayQueue Class A queue can be managed using an array in which index 0 represents one end An integer value rear represents the next open slot in the array and the number of elements currently in the queue The challenge with this approach is that a queue operates on both ends, so the elements in the array must be shifted to keep one end at index 0

29. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-29 figure 7.13 An array implementation of a queue

30. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-30 The enqueue Operation //----------------------------------------------------------------- // Adds the specified element to the rear of the queue, expanding // the capacity of the queue array if necessary. //----------------------------------------------------------------- public void enqueue (Object element) { if (size() == queue.length) expandCapacity(); queue[rear] = element; rear++; }

31. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-31 figure 7.14 The queue after adding element E

32. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-32 The dequeue Operation //----------------------------------------------------------------- // Removes the element at the front of the queue and returns a // reference to it. Throws an EmptyCollectionException if the // queue is empty. //----------------------------------------------------------------- public Object dequeue () throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); Object result = queue[0]; // shift the elements for (int scan=0; scan < rear; scan++) queue[scan] = queue[scan+1]; rear--; queue[rear] = null; return result; }

33. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-33 figure 7.15 The queue after removing the first element

34. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-34 The CircularArrayQueue Class If we don't fix one end of the queue at index 0, we won't have to shift the elements A circular queue is an implementation of a queue using an array that conceptually loops around on itself That is, the last index is thought to precede index 0 We keep track of integers that indicate where the front and rear of the queue are at any given time

35. figure 7.16 A circular array implementation of a queue

36. figure 7.17 A queue straddling the end of a circular array

37. figure 7.18 Changes in a circular array implementation of a queue

38. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-38 Circular Queues When an element is enqueued, the value of rear is incremented But it must take into account the need to loop back to 0: rear = (rear+1) % queue.length; Note that this array implementation can also reach capacity and may need enlarging

39. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-39 Queue Implementations The linked implementation of a queue does not suffer from the need to operate on both ends of the queue The enqueue operation is O(1) for all implementations The dequeue operation is O(1) for linked and circular array implementations, but O(n) for the noncircular array version