CS210- Lecture 5 Jun 9, 2005 Agenda Queues Array Based Implementation of Queues Applications of Queues Linked Lists 2/24/2019 CS210-Summer 2005, Lecture 5

Queues Queue is a container of objects that are inserted and removed according to the first-in first-out (FIFO) principle. Objects can be inserted into a queue at any time, but only the objects that has been in the queue the longest can be removed. Objects enter the queue at the rear and are removed from the front. 2/24/2019 CS210-Summer 2005, Lecture 5

Queue ADT Queue ADT supports following methods: enqueue(o): Insert object o at the rear of the queue. Input: Object o Output: None dequeue(): Remove and return from the queue the object at the front. Error occurs if the queue is empty. Input: None Output: Front object 2/24/2019 CS210-Summer 2005, Lecture 5

Queue ADT size(): Return the number of objects in the queue Input: none Output: Integer (total number of objects) isEmpty(): Return a boolean indicating if the queue is empty. Input: None Output: boolean (true if queue is empty, false otherwise) 2/24/2019 CS210-Summer 2005, Lecture 5

Queue ADT front(): Return but do not remove, the front object in the queue. Error occurs if the queue is empty. Input: None Output: Front object Exceptions Attempting the execution of dequeue or front on an empty queue throws an EmptyQueueException. 2/24/2019 CS210-Summer 2005, Lecture 5

Example Operation 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) 2/24/2019 CS210-Summer 2005, Lecture 5

Applications of Queues Waiting lists: Stores, Theaters etc. Access to Shared resources (printer). Multiprogramming 2/24/2019 CS210-Summer 2005, Lecture 5

Queue Interface Java interface corresponding to our Queue ADT public interface Queue { public int size(); public boolean isEmpty(); public Object front() throws EmptyQueueException; public void enqueue(Object o); public Object dequeue() throws EmptyQueueException; } Java interface corresponding to our Queue ADT Requires the definition of class EmptyQueueException No corresponding built-in Java class 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation We must decide how we are going to keep track of the rare and front of the queue. One possibility is to adapt the approach we used in stack. Q[0] be the front. Not efficient as need to move all elements forward one array cell each time we perform a dequeue operation. Dequeue operation will take O(n) time. 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation Two variables keep track of the front and rear f index of the front element r index immediately past the rear element Array location r is kept empty. Initially f = r = 0 (initially empty) When we remove an element from front of the queue, we increment f to index the next cell. 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation When we add an element, we store it in cell Q[r] and increment r to index the next available cell in Q. This allows us to implement all methods in O(1) time. There is still a problem with this approach. 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation Q f, r Q 4 enqueue(4) f r Q dequeue(4) f, r Q 4 enqueue(4) f r If we do enqueue(4) and dequeue(4) 7 times. We would have f = r = 7. Next time we will get ArrayOutOfBoundsException. 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation Solution: Use an array of size N in a circular fashion We let the f and r indices wrap around the end of Q. normal configuration Q 1 2 r f wrapped-around configuration Q 1 2 f r 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation We compute the increment of f and r as (f + 1) mod N (r + 1) mod N Another problem: If we enqueue N objects into Q without dequeuing any of them. We would have f = r, which is the same condition that occurs when the queue is empty. No difference between full queue and empty queue. 2/24/2019 CS210-Summer 2005, Lecture 5

A Simple Array based implementation Solution: Insist that Q can never hold more than N – 1 objects. Size ? (N – f + r) mod N. When list is empty f = r = 0 Size = N mod N = 0 When list is full i.e N – 1 elements f = 0 r = N – 1 Size = (N – 0 + N – 1) mod N = N - 1 2/24/2019 CS210-Summer 2005, Lecture 5

Queue Operations We use the modulo operator (remainder of division) Algorithm size() return (N - f + r) mod N Algorithm isEmpty() return (f = r) Q 1 2 r f Q 1 2 f r 2/24/2019 CS210-Summer 2005, Lecture 5

Queue Operations Operation enqueue throws an exception if the array is full This exception is implementation-dependent Algorithm enqueue(o) if size() = N  1 then throw FullQueueException else Q[r]  o r  (r + 1) mod N Q 1 2 r f Q 1 2 f r 2/24/2019 CS210-Summer 2005, Lecture 5

Queue Operations Operation dequeue throws an exception if the queue is empty This exception is specified in the queue ADT Algorithm dequeue() if isEmpty() then throw EmptyQueueException else o  Q[f] f  (f + 1) mod N return o Q 1 2 r f Q 1 2 f r 2/24/2019 CS210-Summer 2005, Lecture 5

Analyzing the Array Based Queue Implementation Method Time size O(1) isEmpty O(1) front O(1) enqueue O(1) dequeue O(1) 2/24/2019 CS210-Summer 2005, Lecture 5

Drawbacks of Array based implementation Array based implementation must assume a fixed upper bound N on the ultimate size of the stack. An application may actually need more or less queue capacity than this. Still in cases where we have a good estimate on the number of items to be stored in the queue, the array based implementation is hard to beat. 2/24/2019 CS210-Summer 2005, Lecture 5

Round Robin Schedulers We can implement a round robin scheduler using a queue, Q, by repeatedly performing the following steps: e = Q.dequeue() Service element e Q.enqueue(e) The Queue Shared Service 1 . Deque the next element 3 Enqueue the serviced element 2 Service the 2/24/2019 CS210-Summer 2005, Lecture 5

The “Pass the Pillow” game A group of n children sit in a circle passing a pillow around the circle. Children continue passing the pillow until a leader rings a bell, at which point the child holding the pillow must leave the game after handling the pillow to the next child in the circle. The process is then continued until there is only one child remaining, who is declared the winner. If leader always rings the bell after the pillow has been passed k times, then determining the winner for a given list of children in known as “Josephus Problem”. 2/24/2019 CS210-Summer 2005, Lecture 5

Singly Linked Lists A singly linked list is a concrete data structure consisting of a sequence of nodes Each node stores element link to the next node next node elem head  A B C D 2/24/2019 CS210-Summer 2005, Lecture 5

Singly Linked Lists The next reference inside a node can be viewed as a link or pointer to another node. Moving from one node to another by following a next reference is known as link hopping or pointer hopping. The first and last node are usually called head and tail of the list resp. Tail has a null next reference which indicates the termination of the list. 2/24/2019 CS210-Summer 2005, Lecture 5

Singly linked list vs. Arrays Like an array, a singly linked list keeps the elements in a certain linear order, which is determined by the chain of next links between the nodes. Unlike an array, a singly linked list does not have a predetermined fixed size, and uses space proportional to the number of its elements. 2/24/2019 CS210-Summer 2005, Lecture 5

Inserting at the head 2/24/2019 CS210-Summer 2005, Lecture 5

Inserting at the head Allocate a new node Insert new element Have new node point to old head Update head to point to new node 2/24/2019 CS210-Summer 2005, Lecture 5

Removing at the head Update head to point to next node in the list Allow garbage collector to reclaim the former first node 2/24/2019 CS210-Summer 2005, Lecture 5

Inserting at the tail 2/24/2019 CS210-Summer 2005, Lecture 5

Inserting at the tail Allocate a new node Insert new element Have new node point to null Have old last node point to new node Update tail to point to new node 2/24/2019 CS210-Summer 2005, Lecture 5

Removing at tail Removing at the tail of a singly linked list is not efficient! There is no constant-time way to update the tail to point to the previous node. 2/24/2019 CS210-Summer 2005, Lecture 5

Analyzing the Singly Linked List Method Time Inserting at the head O(1) Inserting at the tail O(1) Deleting at the head O(1) Deleting at the tail O(n) 2/24/2019 CS210-Summer 2005, Lecture 5