1

M180: Data Structures & Algorithms in Java

Queues

Arab Open University

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

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.

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

Queue ExampleOperation Output Q 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)

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

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

17 23 97 440 1 2 3 4 5 6 7

myQueue:

rear = 3front = 0

8

Array implementation of queues

• Notice how the array contents “crawl” to the right as elements are inserted and deleted

17 23 97 44 333After insertion:

23 97 44 333After deletion:

rear = 4front = 1

17 23 97 44Initial queue:

rear = 3front = 0

9

Circular arrays• We can treat the array holding the queue elements as

circular (joined at the ends)

44 55 11 22 330 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

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:

44 55 66 77 88 11 22 330 1 2 3 4 5 6 7

myQueue:

rear = 4 front = 5

0 1 2 3 4 5 6 7myQueue:

rear = 4 front = 5This is a problem!

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

44 55 66 77 88 11 22 330 1 2 3 4 5 6 7

myQueue:

rear = 4 front = 5count = 8

44 55 66 77 11 22 330 1 2 3 4 5 6 7

myQueue:

rear = 3 front = 5

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

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

Interfaces Definition

• Syntax:

• Example:

interface InterfaceName {// Constant/Final Variable Declaration// Methods Declaration – only method

body}

interface Speaker {public void speak( );

}

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

Implementing Interfaces Exampleclass 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

Queue Interfacepublic 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

Array-Queue Implementationprivate 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

Queue Implementationpublic void makeEmpty( )    {        currentSize = 0;        front = 0;        back = -1;    }   

    public int dequeue( )    {        if( !isEmpty( ) )             currentSize--;

        int returnValue = theArray[ front ];        front = increment( front );        return returnValue;    } 

Queue Implementationpublic 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

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;    }}