Download ADTs, Stacks and Queues

ADTs, Stacks and Queues
Readings - Chapter 6
1
Abstract Data Types
ADT
2
Abstract Data Types (ADTs)
An abstract data type (ADT) is a
mathematically specified entity that
defines a set of its instances.
q  An ADT specifies:
q 
What data is stored
n  Interface - Operations on the data
n 
w  manipulation
w  access
n 
a set of axioms (preconditions and post
conditions) that define what the operations
do (not how)
ADT
3
Why Abstract Data Types (ADTs)
serve as specifications of requirements
for the building blocks of an algorithm
q  encapsulate the data structure and the
algorithms that works on the data
structure
q  separate issues of correctness and
efficiency
q 
ADT
4
ADT Example - Order Book of a Stock
Trading System - Dynamic Set
q 
The data stored are
Stock
n  Shares
n  Price
n  Buy/Sell
n 
q 
Element
The operations supported are
w  New(): ADT
w  Add(B:ADT, e:Element): ADT
w  Remove(B:ADT, e:Element): ADT
w  isIn(B:ADT, e:Element): boolean
ADT
5
ADT Example - Order Book of a Stock
Trading System - Dynamic Set
q 
The data stored are
Stock
n  Shares
n  Price
n  Buy/Sell
n 
q 
Element
The operations supported are
w  New(): ADT
Constructor
w  Add(B:ADT, e:Element): ADT
w  Remove(B:ADT, e:Element): ADT
w  isIn(B:ADT, e:Element): boolean
ADT
6
ADT Example - Order Book of a Stock
Trading System - Dynamic Set
q 
The data stored are
Stock
n  Shares
n  Price
n  Buy/Sell
n 
q 
Element
The operations supported are
w  New(): ADT
Constructor
w  Add(B:ADT, e:Element): ADT
Manipulation
w  Remove(B:ADT, e:Element): ADT
Operations
w  isIn(B:ADT, e:Element): boolean
ADT
7
ADT Example - Order Book of a Stock
Trading System - Dynamic Set
q 
The data stored are
Stock
n  Shares
n  Price
n  Buy/Sell
n 
q 
Element
The operations supported are
w  New(): ADT
Constructor
w  Add(B:ADT, e:Element): ADT
Manipulation
w  Remove(B:ADT, e:Element): ADT
Operations
w  isIn(B:ADT, e:Element): boolean
Access
ADT
8
ADT Example - Order Book of a Stock
Trading System - Dynamic Set
q 
Axioms that define the methods
isIn(New(), e) - false
n  isIn(Add(B, e), e) - true
n  isIn(Add(B, f), e) - isIn(B, e) if e≠f
n  isIn(Remove(B, e), e) - false
n  isIn(Remove(B, f), e) = isIn(B, e), if e≠f
n 
ADT
9
The Stack ADT
q 
q 
Container of abstract objects that are inserted and
removed according to the last-in-first-out (LIFO)
principle
Objects can be inserted at any time, but only the
most-recently inserted object can be removed
n 
n 
Inserting an object - push
removing an object - pop
Stacks
10
The Stack ADT - Specification
Data Object
q  Operations
q 
new():ADT - creates a new stack
n  push(S:ADT, o:Object):ADT - Inserts
object o onto the top of stack S
n  pop(S:ADT):ADT - removes the top object
of stack S; if the stack is empty an error
occurs
n 
Stacks
11
The Stack ADT - Specification
(contd)
q 
Auxiliary operations
n 
n 
n 
q 
top(S:ADT):Object - returns the top object of
stack S without removing it; if the stack is
empty, an error occurs
size(S:ADT):integer returns the number of
objects in stack S
isEmpty(S:ADT):boolean - indicates if stack S
is empty
Axioms
n 
n 
pop(push(S, o)) = S
top(push(S, o)) = o
Stacks
12
Stack - Example
Stacks
13
Stack ADT specification in JAVA?
Interfaces
q 
Interface - collection of method
declarations with no data and no bodies
write down the method names and the
parameters (essentially the types)
n  when a class implements an interface, it
must implement all the methods declared in
the interface.
n  Separating interface and
implementation is a useful programming
technique.
n 
Stacks
14
Stack Interface in Java
q 
java.util has a built-in stack data structure
class - we will define our own interface and
not use the built-in class
public interface Stack<E> {!
// accessor methods!
public int size(); // returns the number of objects in the
stack!
public boolean isEmpty();
// returns true if the stack is
empty, false otherwise!
public E top(); throws StackEmptyException; // returns the
top object of the stack!
!
// manipulation/update methods!
public void push(E o); // inserts the object at the top of
the stack!
public E pop(); throws StackEmptyException; // removes and
returns the object at the top of the stack!
}
Stacks
15
Stack ADT specification in JAVA?
Exceptions
q 
unexpected events that occur during the
execution of a program
n 
useful for handling errors
when an error (or an exceptional event is
encountered, the Java code throws an
exception
q  Upon throwing an exception, the control
flow exits from the current method and
goes to the parent calling method
q 
n 
responsibility of handling the error can be
delegated to the parent method
Stacks
16
Exceptions - Example
public void UpdateStudentScore(Student s) throws
StudentNotFoundException {!
...!
if (s is not part of CSL201)!
throw new StudentNotFoundException(s+"is not a student
in CSL201");!
...!
}!
!
public void UpdateClassScore() {!
...!
try {!
CSL201.UpdateStudentScore(s);!
}!
catch (StudentNotFoundException e) {!
system.out.println(e);!
}!
...!
}
Stacks
17
More Exceptions - Try and Catch
try - guarded fragment of code that might
thrown an exception when executed.
q  catch - block of code to which control
jumps on catching an exception. The block
contains code to analyze the exception and
apply an appropriate solution.
q  If an exception is never caught in a
method, it will propagate upwards along
the sequence of method calls until the user
sees it.
q  Exceptions are essentially Java Classes
q 
n 
Section 2.4
Stacks
18
Stack Interface in Java - Finally
q 
java.util has a built-in stack data structure
class - we will define our own interface and
not use the built-in class
public interface Stack<E> {!
// accessor methods!
public int size(); // returns the number of objects in the
stack!
public boolean isEmpty();
// returns true if the stack is
empty, false otherwise!
public E top() throws StackEmptyException; // returns the top
object of the stack!
!
// manipulation/update methods!
public void push(E o); // inserts the object at the top of
the stack!
public E pop() throws StackEmptyException; // removes and
returns the object at the top of the stack!
}
Stacks
19
Array-Based Stack
Implementation in Java
q 
Simple way to implement a stack
n 
specify the maximum size N of our stack
Add elements left to right
q  variable t keeps track of the top element
of the array stack S
q 
…
S
0 1 2
q 
t
array indices start at 0, so we initialize t
to -1
Stacks
20
Array-Based Stack
Implementation in Java - 1
public class ArrayStack<E> implements Stack<E> {!
/** Default array capacity. */!
public static final int CAPACITY=1000;
// default array capacity!
!
/** Generic array used for storage of stack elements. */!
private E[] data;
// generic array used for storage!
!
/** Index of the top element of the stack in the array. */!
private int t = -1;
// index of the top element in
stack!
!
/** Constructs an empty stack using the default array capacity. */!
public ArrayStack() { this(CAPACITY); } // constructs stack with default
capacity!
!
/**!
* Constructs and empty stack with the given array capacity.!
* @param capacity length of the underlying array!
*/!
public ArrayStack(int capacity) {
// constructs stack with given
capacity!
data = (E[]) new Object[capacity];
!
}
Stacks
21
Array-Based Stack
Implementation in Java - 2
/**!
* Returns the number of elements in the stack.!
* @return number of elements in the stack!
*/!
public int size() { return (t + 1); }!
!
/**!
* Tests whether the stack is empty.!
* @return true if the stack is empty, false otherwise!
*/!
public boolean isEmpty() { return (t == -1); }!
!
/**!
* Inserts an element at the top of the stack.!
* @param e
the element to be inserted!
* @throws StackFullException if the array storing the elements is full!
*/!
public void push(E e) throws StackFullException {!
if (size() == data.length) throw new StackFullException("Stack is full");!
data[++t] = e;
// increment t before storing
new item!
}
Stacks
22
Array-Based Stack
Implementation in Java - 3
/**!
* Returns, but does not remove, the element at the top of the stack.!
* @return top element in the stack (or null if empty)!
* @throws StackEmptyException if the array storing the stack is empty!
*/!
public E top() {!
if (isEmpty()) throw new StackEmptyException ("Stack is empty”);!
return data[t];!
}!
!
/**!
* Removes and returns the top element from the stack.!
* @return element removed!
* @throws StackEmptyException if the array storing the stack is empty!
*/!
public E pop() {!
if (isEmpty()) throw new StackEmptyException ("Stack is empty”);!
E answer = data[t];!
data[t] = null;
// dereference to help garbage
collection!
t--;!
return answer;!
}
Stacks
23
Array-Based Stack
Performance and Limitations
q 
Performance
n 
implementation is simple and efficient
w  methods performed in O(1)
n 
q 
Space complexity - O(N)
Limitations
n 
maximum capacity of the array has to be specified
a priori
w  too large - wastage of space
w  too small - insufficient for a given application
n 
n 
StackFullException is specific to this
implementation
StackEmptyException is required by the
interface
Stacks
24
A Growable Array-Based Stack
q 
On StackFullException, replace the array S
with a larger one and continue processing
the push operations
Algorithm push(o)
if size()=N then A new array of length f(N)
for i ç 0 to N-1
A[i] ç S[i]
S ç A
t ç t+1
S[t] ç o
q 
How large should the new array be?
n 
n 
tight strategy - add a constant f(N) = N+c
growth strategy - double up f(N) = 2N
Stacks
25
Comparing Tight and Growth
Strategies
q 
cost model
n 
regular push - when array capacity is not
exceeded; adds one element
w  costs 1 unit
n 
special push - when a new array is created
and elements of the old array are copied
before adding one element.
w  costs f(N)+N+1 units
Stacks
26
Tight Strategy (c=4)
q 
start with an array size of 0
a
4 + 1
a b
1
a b c
1
a b c d
1
a b c d e
8 + 4 + 1
a b c d e f
1
a b c d e f
g
1
a b c d e f
g h
1
a b c d e f
g h i
1 2 + 8 + 1
a b c d e f
g h i
j
a b c d e f
g h i
j
k
1
a b c d e f
g h i
j
k l
1
cost of
special push
2n+5
for a total of n
pushes
cost is O(n^2/c)
1
Stacks
27
Growth Strategy (double the size)
q 
start with an array size of 0
a
1 + 0 + 1
a b
2 + 1 + 1
a b c
4 + 2 + 1
a b c d
1
a b c d e
8 + 4 + 1
a b c d e f
1
a b c d e f g
1
a b c d e f g h
1
a b c d e f g h i
.
1 6 + 8 + 1
a b c d e f g h i
j
.
1
a b c d e f g h i
j k
.
1
a b c d e f g h i
j k l
.
1
Stacks
cost of
special push
3n+1
for a total of n
pushes
cost is O(n)
28
Linked List-Based Stack
Implementation in Java - 1
public class LinkedStack<E> implements Stack<E> {!
!
/** The primary storage for elements of the stack */!
private SinglyLinkedList<E> list = new
SinglyLinkedList<>();
// an empty list!
!
/** Constructs an initially empty stack. */!
public LinkedStack() { }
// new
stack relies on the initially empty list!
!
/**!
* Returns the number of elements in the stack.!
* @return number of elements in the stack!
*/!
public int size() { return list.size(); }!
!
Stacks
29
Linked List-Based Stack
Implementation in Java - 2
/**!
* Tests whether the stack is empty.!
* @return true if the stack is empty, false otherwise!
*/!
public boolean isEmpty() { return list.isEmpty(); }
!
/**!
* Inserts an element at the top of the stack.!
* @param element
the element to be inserted!
*/!
public void push(E element) { list.addFirst(element); }!
!
!
Stacks
30
Linked List-Based Stack
Implementation in Java - 3
/**!
* Returns, but does not remove, the element at the top of the stack.!
* @return top element in the stack!
* @throws StackEmptyException if the list storing the stack is empty!
*/!
public E top() {!
if (isEmpty()) throw new StackEmptyException ("Stack is empty”);!
return list.first(); !
}!
!
/**!
* Removes and returns the top element from the stack.!
* @return element removed !
* @throws StackEmptyException if the list storing the stack is empty!
*/!
public E pop() {!
if (isEmpty()) throw new StackEmptyException ("Stack is empty”);!
return list.removeFirst(); !
}
Stacks
31
Applications of Stacks
q 
Direct applications
Page-visited history in a Web browser
n  Undo sequence in a text editor
n  Chain of method calls in the Java Virtual
Machine
n 
q 
Indirect applications
Auxiliary data structure for algorithms
n  Component of other data structures
n 
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
32
Stack Applications Chain of Method Calls in JVM
q 
q 
q 
q 
The Java Virtual Machine (JVM) main() {
keeps track of the chain of
int i = 5;
active methods with a stack
foo(i);
When a method is called, the
}
JVM pushes on the stack a
frame containing
foo(int j) {
n  Local variables and return value
int k;
n  Program counter, keeping track of
the statement being executed
k = j+1;
When a method ends, its frame
bar(k);
is popped from the stack and
}
control is passed to the method
on top of the stack
bar(int m) {
Allows for recursion
…
}
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
bar
PC = 1
m=6
foo
PC = 3
j=5
k=6
main
PC = 2
i=5
33
Stack ApplicationsEvaluating Arithmetic Expressions
14 – 3 * 2 + 7 = (14 – (3 * 2) ) + 7
Slide by Matt Stallmann
included with permission.
Operator precedence
* has precedence over +/–
Associativity
operators of the same precedence group
evaluated from left to right
Example: (x – y) + z rather than x – (y + z)
Idea: push each operator on the stack, but first pop and
perform higher and equal precedence operations.
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
34
Algorithm for
Evaluating Expressions
Two stacks:
q 
opStk holds operators
q 
valStk holds values
q  Use $ as special “end of input”
token with lowest precedence
Algorithm doOp()
x ← valStk.pop();
y ← valStk.pop();
op ← opStk.pop();
valStk.push( y op x )
Algorithm repeatOps( refOp ):
while ( valStk.size() > 1 ∧
prec(refOp) ≤
prec(opStk.top())
doOp()
© 2014 Goodrich, Tamassia, Goldwasser
Slide by Matt Stallmann
included with permission.
Algorithm EvalExp()
Input: a stream of tokens representing
an arithmetic expression (with
numbers)
Output: the value of the expression
while there’s another token z
if isNumber(z) then
valStk.push(z)
else
repeatOps(z);
opStk.push(z)
repeatOps($);
return valStk.top()
Stacks
35
Algorithm on an
Example Expression
Slide by Matt Stallmann
included with permission.
14 ≤ 4 – 3 * 2 + 7
Operator ≤ has lower
precedence than +/–
4
14
–
≤
3
4
14
*
–
≤
$
7
-2
14
+
2
3
4
14
*
–
≤
2
3
4
14
+
*
–
≤
© 2014 Goodrich, Tamassia, Goldwasser
6
4
14
–
≤
Stacks
-2
14
$
$
+
≤
5
14
F
≤
+
≤
36
Computing Spans (not in book)
q 
q 
q 
Using a stack as an
auxiliary data structure in
an algorithm
Given an an array X, the
span S[i] of X[i] is the
maximum number of
consecutive elements X[j]
immediately preceding X[i]
and such that X[j] ≤ X[i]
Spans have applications to
financial analysis
n 
E.g., stock at 52-week high
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
7
6
5
4
3
2
1
0
0
X
S
1
6
1
3
1
2
3
4
2
5
3
4
2
1
37
Quadratic Algorithm
Algorithm spans1(X, n)
Input array X of n integers
Output array S of spans of X
#
S ← new array of n integers
n
for i ← 0 to n - 1 do
n
s←1
n
while s ≤ i ∧ X[i - s] ≤ X[i] 1 + 2 + …+ (n - 1)
s←s+1
1 + 2 + …+ (n - 1)
S[i] ← s
n
return S
1
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
38
Computing Spans with a Stack
q 
q 
We keep in a stack the
indices of the elements
visible when “looking
back”
We scan the array from
left to right
n 
n 
n 
n 
Let i be the current index
We pop indices from the
stack until we find index j
such that X[i] < X[j]
We set S[i] ← i - j
We push i onto the stack
© 2014 Goodrich, Tamassia, Goldwasser
Stacks
7
6
5
4
3
2
1
0
0 1 2 3 4 5 6 7
39
Efficient Algorithm
q 
Each index of the
array
q 
q 
q 
q 
Is pushed into the
stack exactly once
Is popped from
the stack at most
once
The statements in
the while-loop are
executed at most n
times
Algorithm spans2
runs in O(n) time
© 2014 Goodrich, Tamassia, Goldwasser
Algorithm spans2(X, n)
#
S ← new array of n integers n
A ← new empty stack
1
for i ← 0 to n - 1 do
n
while (¬A.isEmpty() ∧
X[A.top()] ≤ X[i] ) do n
A.pop()
n
if A.isEmpty() then
n
S[i] ← i + 1
n
else
S[i] ← i - A.top()
n
A.push(i)
n
return S
1
Stacks
40
Efficient Algorithm
7
6
5
4
3
2
1
0
0
X
S
1
6
1
3
1
2
3
4
2
5
3
4
2
1
© 2014 Goodrich, Tamassia, Goldwasser
Algorithm spans2(X, n)
#
S ← new array of n integers n
A ← new empty stack
1
for i ← 0 to n - 1 do
n
while (¬A.isEmpty() ∧
X[A.top()] ≤ X[i] ) do n
A.pop()
n
if A.isEmpty() then
n
S[i] ← i + 1
n
else
S[i] ← i - A.top()
n
A.push(i)
n
return S
1
Stacks
41
Java File I/O using Buffered and
File Readers
import java.io.*;!
import java.util.Scanner;!
!
!
public class FileScan{!
public static void main(String[] args) throws IOException {!
Scanner s = null;!
try {!
s = new Scanner(new BufferedReader(new
FileReader(“test.txt”)));!
!
while (s.hasNext()) {!
System.out.println(s.next());!
}!
} finally {!
if (s != null) {!
s.close();!
}!
}!
}!
}
Java File I/O
42
Queues
Readings - 6.2 and 6.3
The Queue ADT
q 
q 
The insertion and removal routines of the
Queue ADT follow the first-in-first-out (FIFO)
principle.
Elements may be inserted at any time, but
only the element which has been in the queue
the longest may be removed.
n 
n 
Inserting an object (at the rear) – enqueue
Removing an object ( from the front) - dequeue
Tickets
Queues
44
The Queue ADT - Specification
q 
q 
Data Object
The queue supports the following
fundamental methods:
n 
n 
n 
n 
New():ADT – creates an empty queue
Enqueue(Q:ADT, o:element):ADT – inserts the object o at
the rear of the queue
Dequeue(Q:ADT):element – removes the object from the
front of the queue; an error occurs if the queue is empty
First(Q:ADT):element – returns, but does not remove the
object at the front of the queue; an error occurs if the queue
is empty.
Queues
45
The Queue ADT - Specification
q 
Auxiliary methods
n 
n 
q 
Size(Q:QDT):integer – returns the number of
elements in the queue
isEmpty(Q:ADT):boolean – indicates whether the
queue is empty
Axioms
n 
n 
n 
n 
Front(Enqueue(New(), v)) = v
Dequeue(Enqueue(New(), v)) = New()
Front(Enqueue(Enqueue(Q,w),v)) =
Front(Enqueue(Q,w))
Dequeue(Enqueue(Enqueue(Q,w), v)) =
Enqueue(Dequeue(Enqueue(Q,w),v)
Queues
46
Example
Operation
enqueue(5)
enqueue(3)
dequeue()
enqueue(7)
dequeue()
first()
dequeue()
dequeue()
isEmpty()
enqueue(9)
enqueue(7)
size()
enqueue(3)
enqueue(5)
dequeue()
© 2014 Goodrich, Tamassia, Goldwasser
–
–
5
–
3
7
7
null
true
–
–
2
–
–
9
Output Q
(5)
(5, 3)
(3)
(3, 7)
(7)
(7)
()
()
()
(9)
(9, 7)
(9, 7)
(9, 7, 3)
(9, 7, 3, 5)
(7, 3, 5)
Queues
47
Queue ADT specification in JAVA
public interface Queue<E> {!
// accessor methods!
int size(); // returns the number of elements in
the queue!
boolean isEmpty(); // returns true if the queue is
empty, false otherwise!
!
//manipulation methods!
void enqueue(E e); // adds the element to the rear
of the queue!
E first() throws QueueEmptyException; // returns
the first element of the queue!
E dequeue() throws QueueEmptyException;
//
removes and returns the first element of the queue!
}!
Queues
48
Array-based Queue
q 
q 
Use an array of size N in a circular fashion
Two variables keep track of the front and size
f index of the front element
sz number of stored elements
q 
When the queue has fewer than N elements, array
location r = (f + sz) mod N is the first empty slot past
the rear of the queue
normal configuration
Q
0 1 2
f
r
wrapped-around configuration
Q
0 1 2
r
f
© 2014 Goodrich, Tamassia, Goldwasser
Queues
49
Queue Operations
q 
We use the modulo operator (remainder of
division)
Algorithm size()
return sz
Algorithm isEmpty()
return (sz == 0)
Q
0 1 2
f
0 1 2
r
r
Q
© 2014 Goodrich, Tamassia, Goldwasser
f
Queues
50
Queue Operations (cont.)
q 
Operation enqueue throws an exception if the array is
full – Implementation specific exception
Algorithm enqueue(o)
if size() = N then
throw QueueFullException
else
r ← (f + sz) mod N
Q[r] ← o
sz ← (sz + 1)
Q
0 1 2
f
0 1 2
r
r
Q
© 2014 Goodrich, Tamassia, Goldwasser
Queues
f
51
Queue Operations (cont.)
q 
Note that operation dequeue throws QueueEmptyException if
the queue is empty
Algorithm dequeue()
if isEmpty() then
throw QueueEmptyException
else
o ← Q[f]
f ← (f + 1) mod N
sz ← (sz - 1)
return o
Q
Q
0 1 2
f
0 1 2
r
© 2014 Goodrich, Tamassia, Goldwasser
r
f
Queues
52
Array-based Implementation
public class ArrayQueue<E> implements Queue<E> {!
// instance variables!
public static final int CAPACITY = 1000;
//
private E[] data;
//
private int f = 0;
//
private int sz = 0;
//
default array capacity!
generic array used for storage!
index of the front element!
current number of elements!
!
// constructors!
public ArrayQueue() {this(CAPACITY);}
// constructs queue with default capacity!
!
public ArrayQueue(int capacity) {
data = (E[]) new Object[capacity];
}!
// constructs queue with given capacity!
// safe cast; compiler may give warning!
!
// methods!
/**!
* Returns the number of elements in the queue.!
* @return number of elements in the queue!
*/!
public int size() { return sz; }!
!
public boolean isEmpty() { return (sz == 0); } // Tests whether the queue is
empty.!
Queues
53
Array-based Implementation (2)
!
/**!
* Inserts an element at the rear of the queue.!
* This method runs in O(1) time.!
* @param e
new element to be inserted!
* @throws QueueFullException if the array storing the elements is full!
*/!
public void enqueue(E e) throws QueueFullException {!
if (sz == data.length) throw new QueueFullException ("Queue is full");!
int avail = (f + sz) % data.length;
// use modular arithmetic!
data[avail] = e;!
sz++;!
}!
!
/**!
* Returns, but does not remove, the first element of the queue.!
* @return the first element of the queue!
* @throws QueueEmptyException if the array storing the elements is empty!
*/!
public E first() throws QueueEmptyException {!
if (isEmpty()) throws new QueueEmptyException() ;!
return data[f];!
}!
Queues
54
Array-based Implementation (3)
/**!
* Removes and returns the first element of the
queue.!
* @return element removed !
* @throws QueueEmptyException if the queue is empty)!
*/!
public E dequeue() throws QueueEmptyException {!
if (isEmpty()) throw new QueueEmptyException ();!
E answer = data[f];!
data[f] = null;
//
dereference to help garbage collection!
f = (f + 1) % data.length;!
sz--;!
return answer;!
}
Queues
55
Applications of Queues
q 
Direct applications
Waiting lists, bureaucracy
n  Access to shared resources (e.g., printer)
n  Multiprogramming
n 
q 
Indirect applications
Auxiliary data structure for algorithms
n  Component of other data structures
n 
© 2014 Goodrich, Tamassia, Goldwasser
Queues
56
Application: Round Robin Schedulers
We can implement a round robin scheduler using a
queue Q by repeatedly performing the following
steps:
q 
1. 
2. 
3. 
e = Q.dequeue()
Service element e
Q.enqueue(e)
Queue
Dequeue
Enqueue
Shared
Service
© 2014 Goodrich, Tamassia, Goldwasser
Queues
57
Double-Ended Queue - Deque
q 
q 
Deque supports insertion and deletion from the
front and back of the queue
The deque ADT supports the following fundamental
methods
n 
n 
n 
n 
n 
n 
InsertFirst(Q:ADT, e:element):ADT – inserts e at the
beginning of the deque
InsertLast(Q:ADT, e:element):ADT – inserts e at the
end of the deque
RemoveFirst(Q:ADT):ADT – removes the first element
RemoveLast(Q:ADT):ADT – removes the last element
First(Q:ADT): element – returns the first element
Last(Q:ADT):element – returns the last element
Queues
58
Deque implementations
q 
Singly linked list
q 
Doubly linked list
A
n 
Tail
B
C
constant time operations
Queues
59