Stacks

week 2a 2

Outline and Reading

The Stack ADT (§4.1)Applications of Stacks Array-based implementation (§4.1.2)Growable array-based stackThink of a spring-loaded plate

dispenser

week 2a 3

Abstract Data Types (ADTs)

An abstract data type (ADT) is an abstraction of a data structureAn ADT specifies: Data stored Operations on

the data Error conditions

associated with operations

Example: ADT modeling a simple stock trading system The data stored are buy/sell

orders The operations supported are

order buy(stock, shares, price) order sell(stock, shares, price) void cancel(order)

Error conditions: Buy/sell a nonexistent stock Cancel a nonexistent order

week 2a 4

The Stack ADTThe Stack ADT stores arbitrary objectsInsertions and deletions follow the last-in first-out schemeMain stack operations: push(object): inserts

an element object pop(): removes

and returns the last inserted element

Auxiliary stack operations:

object top(): returns the last inserted element without removing it

integer size(): returns the number of elements stored

boolean isEmpty(): indicates whether no elements are stored

week 2a 5

ExceptionsAttempting the execution of an operation of ADT may sometimes cause an error condition, called an exceptionExceptions are said to be “thrown” by an operation that cannot be executed

In the Stack ADT, operations pop and top cannot be performed if the stack is emptyAttempting the execution of pop or top on an empty stack throws an EmptyStackException

week 2a 6

Applications of Stacks

Direct applications Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java

Virtual Machine

Indirect applications Auxiliary data structure for algorithms Component of other data structures

week 2a 7

Method Stack in the JVMThe Java Virtual Machine (JVM) keeps track of the chain of active methods with a stackWhen a method is called, the JVM pushes on the stack a frame containing

Local variables and return value Program counter, keeping track

of the statement being executed

When a method ends, its frame is popped from the stack and control is passed to the method on top of the stack

main() {int i = 5;foo(i);}

foo(int j) {int k;k = j+1;bar(k);}

bar(int m) {…}

bar PC = 1 m = 6

foo PC = 3 j = 5 k = 6

main PC = 2 i = 5

week 2a 8

Array-based StackA simple way of implementing the Stack ADT uses an arrayWe add elements from left to rightA variable keeps track of the index of the top element

S0 1 2 t

…

Algorithm size()return t + 1

Algorithm pop()if isEmpty() then

throw EmptyStackException else

t t 1return S[t + 1]

week 2a 9

Array-based Stack (cont.)The array storing the stack elements may become fullA push operation will then throw a FullStackException

Limitation of the array-based implementation

Not intrinsic to the Stack ADT

S0 1 2 t

…

Algorithm push(o)if t = S.length 1 then

throw FullStackException else

t t + 1S[t] o

week 2a 10

Performance and Limitations

Performance Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1)

Limitations The maximum size of the stack must be

defined a priori and cannot be changed Trying to push a new element into a full stack

causes an implementation-specific exception

week 2a 11

Computing SpansWe show how to use a stack as an auxiliary data structure in an algorithmGiven 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

E.g., stock at 52-week high

6 3 4 5 2

1 1 2 3 1

X

S

01234567

0 1 2 3 4

week 2a 12

Quadratic AlgorithmAlgorithm spans1(X, n)

Input array X of n integersOutput array S of spans of X #S new array of n integers nfor i 0 to n 1 do n

s 1 nwhile 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

Algorithm spans1 runs in O(n2) time

week 2a 13

Computing Spans with a Stack

We keep in a stack the indices of the elements visible when “looking back”We scan the array from left to right

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

01234567

0 1 2 3 4 5 6 7

week 2a 14

Linear AlgorithmAlgorithm spans2(X, n) #

S new array of n integers nA new empty stack 1

for i 0 to n 1 do nwhile (A.isEmpty()

X[top()] X[i] ) do n A.pop() n

if A.isEmpty() then nS[i] i 1 n

else S[i] i A.top() n

A.push(i) nreturn S 1

Each index of the array

Is pushed into the stack exactly one

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

week 2a 15

Growable Array-based Stack

In a push operation, when the array is full, instead of throwing an exception, we can replace the array with a larger oneHow large should the new array be? incremental strategy:

increase the size by a constant c

doubling strategy: double the size

Algorithm push(o)if t = S.length 1 then

A new array ofsize …

for i 0 to t do A[i] S[i] S A

t t + 1S[t] o

week 2a 16

Comparison of the Strategies

We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operationsWe assume that we start with an empty stack represented by an array of size 1We call amortized time of a push operation the average time taken by a push over the series of operations, i.e., T(n)/n

week 2a 17

Incremental Strategy Analysis

We replace the array k = n/c timesThe total time T(n) of a series of n push operations is proportional to

n + c + 2c + 3c + 4c + … + kc =n + c(1 + 2 + 3 + … + k) =

n + ck(k + 1)/2Since c is a constant, T(n) is O(n + k2), i.e., O(n2)The amortized time of a push operation is O(n)

week 2a 18

Doubling Strategy AnalysisWe replace the array k = log2 n timesThe total time T(n) of a series of n push operations is proportional to

n + 1 + 2 + 4 + 8 + …+ 2k =n 2k + 1 1 = 2n 1

T(n) is O(n)The amortized time of a push operation is O(1)

geometric series

1

2

14

8

week 2a 19

Stack Interface in Java

Java interface corresponding to our Stack ADTRequires the definition of class EmptyStackExceptionDifferent from the built-in Java class java.util.Stack

public interface Stack {

public int size();

public boolean isEmpty();

public Object top()throws EmptyStackException;

public void push(Object o);

public Object pop() throws EmptyStackException;

}

week 2a 20

Array-based Stack in Javapublic class ArrayStack

implements Stack {

// holds the stack elements private Object S[ ];

// index to top elementprivate int top = -1;

// constructorpublic ArrayStack(int capacity) {

S = new Object[capacity]); }

public Object pop()throws EmptyStackException {

if isEmpty()throw new EmptyStackException

(“Empty stack: cannot pop”);Object temp = S[top];// facilitates garbage collection S[top] = null;top = top – 1;return temp;

}

Queues

week 2a 22

Outline and Reading

The Queue ADT (§4.2)Implementation with a circular array (§4.2.2)Growable array-based queueQueue interface in Java

week 2a 23

The Queue ADTThe Queue ADT stores arbitrary objectsInsertions and deletions follow the first-in first-out schemeInsertions are at the rear of the queue and removals are at the front of the queueMain 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

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

Exceptions Attempting the execution

of dequeue or front on an empty queue throws an EmptyQueueException

week 2a 24

Applications of Queues

Direct applications Waiting lists, bureaucracy Access to shared resources (e.g.,

printer) Multiprogramming

Indirect applications Auxiliary data structure for algorithms Component of other data structures

week 2a 25

Array-based QueueUse an array of size N in a circular fashionTwo variables keep track of the front and rearf index of the front elementr index immediately past the rear element

Array location r is kept empty

Q0 1 2 rf

normal configuration

Q0 1 2 fr

wrapped-around configuration

week 2a 26

Queue OperationsWe use the modulo operator (remainder of division)

Algorithm size()return (N f + r) mod N

Algorithm isEmpty()return (f r)

Q0 1 2 rf

Q0 1 2 fr

week 2a 27

Queue Operations (cont.)Algorithm enqueue(o)

if size() = N 1 thenthrow FullQueueException

else Q[r] or (r + 1) mod N

Operation enqueue throws an exception if the array is fullThis exception is implementation-dependent

Q0 1 2 rf

Q0 1 2 f r

week 2a 28

Queue Operations (cont.)Operation dequeue throws an exception if the queue is emptyThis exception is specified in the queue ADT

Algorithm dequeue()if isEmpty() then

throw EmptyQueueException else

o Q[f]f (f + 1) mod Nreturn o

Q0 1 2 rf

Q0 1 2 rf

week 2a 29

Growable Array-based Queue

In an enqueue operation, when the array is full, instead of throwing an exception, we can replace the array with a larger oneSimilar to what we did for an array-based stackThe enqueue operation has amortized running time O(n) with the incremental strategy O(1) with the doubling strategy

week 2a 30

Queue Interface in Java

Java interface corresponding to our Queue ADTRequires the definition of class EmptyQueueExceptionNo corresponding built-in Java class

public interface Queue {

public int size();

public boolean isEmpty();

public Object front()throws EmptyQueueException;

public void enqueue(Object o);

public Object dequeue() throws EmptyQueueException;

}

week 2a 31

Creativity:

Describe in pseudo-code a linear-time algorithm for reversing a queue Q. To access the queue, you are only allowed to use the methods of queue ADT.

week 2a 32

Answer:

Algorithm reverseQueue(Queue Q)Create new stack Swhile (not Q.isEmpty()) do

S.push(Q.dequeue())while (not S.isEmpty()) do

Q.enqueue(S.pop())