1. M180: Data Structures & Algorithms in Java Queues Arab Open University 1

2. 2 The Queue ADT The Queue ADT stores arbitrary objects. Insertions and deletions follow the first-in first-out scheme. Insertions are at the rear of the queue and removals are at the front of the queue. Main queue operations: –enqueue(object): inserts an element at the end of the queue –object dequeue(): removes and returns the element at the front of the queue

3. 3 The Queue ADT Auxiliary queue operations: –object front(): returns the element at the front without removing it. –integer size(): returns the number of elements stored. –boolean isEmpty(): indicates whether no elements are stored. –The length of a queue is the number of elements it contains.

4. Applications of Queues  Scheduler for controlling access to shared resources ‒ maintains queues of printers’ jobs ‒ maintains queues of disk input/output requests  Simulation of real word situations ‒ use queues to simulate waiting queues in real scenarios  Telephone operators ‒ queuing system for handling calls to toll-free numbers.

5. 5 Queue Example OperationOutputQ enqueue( 5 ) – ( 5 ) enqueue( 3 ) – ( 5, 3 ) dequeue() 5 ( 3 ) enqueue( 7 ) – ( 3, 7 ) dequeue() 3 ( 7 ) front() 7 ( 7 ) dequeue() 7 () dequeue() “error” () isEmpty() true () enqueue( 9 ) – ( 9 ) enqueue( 7 ) – ( 9, 7 ) size( )2 ( 9, 7 ) enqueue( 3 ) – ( 9, 7, 3 ) enqueue( 5 ) – ( 9, 7, 3, 5 ) dequeue() 9 ( 7, 3, 5 )

6. Specifying operations of a Queue enqueue(newElem) // Inserts newElem at the back of the queue, if there is no violation of createQueue // Create an empty queue isEmpty( ) // Determines if a queue is empty getFront( ) // Returns, but does not remove, the head of the queue. dequeue( ) // Retrieves and removes the head of the queue.

7. 7 Array implementation of queues This is accomplished by inserting at one end (the rear) and deleting from the other (the front) To insert: put new element in location 4, and set rear to 4 To delete: take element from location 0, and set front to 1 17239744 0 1 2 3 4 5 6 7 myQueue: rear = 3front = 0

8. 8 Array implementation of queues Notice how the array contents “crawl” to the right as elements are inserted and deleted 17239744333 After insertion: 239744333 After deletion: rear = 4 front = 1 17239744 Initial queue: rear = 3 front = 0

9. 9 Circular arrays We can treat the array holding the queue elements as circular (joined at the ends) 4455112233 0 1 2 3 4 5 6 7 myQueue: rear = 1 front = 5 Elements were added to this queue in the order 11, 22, 33, 44, 55, and will be removed in the same order Use: front = (front + 1) % myQueue.length; and: rear = (rear + 1) % myQueue.length;

10. 10 Full and empty queues If the queue were to become completely full, it would look like this: If we were then to remove all eight elements, making the queue completely empty, it would look like this: 4455667788112233 0 1 2 3 4 5 6 7 myQueue: rear = 4front = 5 0 1 2 3 4 5 6 7 myQueue: rear = 4front = 5 This is a problem!

11. 11 Full and empty queues: solutions Solution #1: Keep an additional variable Solution #2: (Slightly more efficient) Keep a gap between elements: consider the queue full when it has n-1 elements 4455667788112233 0 1 2 3 4 5 6 7 myQueue: rear = 4front = 5count = 8 44556677112233 0 1 2 3 4 5 6 7 myQueue: rear = 3front = 5

12. 12 Queue Interface in Java Java interface corresponding to our Queue ADT. No corresponding built-in Java class public interface Queue { public int size(); public boolean isEmpty(); public Object front(); public void enqueue(Object o); public Object dequeue(); }

13. 13 Interfaces Can contain only constants (final variables) and abstract method (no implementation). An interface is basically a kind of class—it contains methods and variables. Therefore, it is the responsibility of the class that implements an interface to supply the code for methods.

14. 14 Interfaces Definition Syntax: Example: interface InterfaceName { // Constant/Final Variable Declaration // Methods Declaration – only method body } interface Speaker { public void speak( ); }

15. 15 Implementing Interfaces Interfaces are used like super-classes who properties are inherited by classes. This is achieved by creating a class that implements the given interface as follows: class ClassName implements InterfaceName [, InterfaceName2, … ] { // Body of Class }

16. 16 Implementing Interfaces Example class Politician implements Speaker { public void speak(){ System.out.println( “ Talk politics ” ); } class Priest implements Speaker { public void speak(){ System.out.println( “ Religious Talks ” ); } class Lecturer implements Speaker { public void speak(){ System.out.println( “ Talks Object Oriented Design and Programming! ” ); }

17. 17 Queue Interface public interface Queue { void enqueue( Object x ); // Insert a new item into the queue. Object getFront( ); // Get the least recently inserted item in the queue Object dequeue( ); // Return and remove the least recently inserted item boolean isEmpty( ); // return true if empty, false otherwise void makeEmpty( ); // Make the queue logically empty. }

18. 18 Array-Queue Implementation private int[ ] theArray; private int currentSize; private int front; private int back; private static final int DEFAULT_CAPACITY = 10; public class ArrayQueue implements Queue { public ArrayQueue( ) { theArray = new int[ DEFAULT_CAPACITY ]; makeEmpty( ); } public boolean isEmpty( ) { return currentSize == 0; }

19. 19 Queue Implementation public void makeEmpty( ) { currentSize = 0; front = 0; back = -1; } public int dequeue( ) { if( !isEmpty( ) ) currentSize--; int returnValue = theArray[ front ]; front = increment( front ); return returnValue; }

20. Queue Implementation public int getFront( ) { if( !isEmpty( ) ) return theArray[ front ]; } public void enqueue( Object x ) { if( currentSize == theArray.length ) doubleQueue( ); back = increment( back ); theArray[ back ] = x; currentSize++; } private int increment( int x ) //Internal method to expand theArray. { if( ++x == theArray.length ) x = 0; return x; }

21. 21 Queue Implementation private void doubleQueue( ) //Internal method to expand theArray. { int [ ] newArray; newArray = new int[ theArray.length * 2 ]; // Copy elements that are logically in the queue for( int i = 0; i < currentSize; i++, front = increment( front ) ) newArray[ i ] = theArray[ front ]; theArray = newArray; front = 0; back = currentSize - 1; } }