Abstract Data Types (ADTs)

Abstract Data Type (ADT) &

Stacks

2012-2013 2

Abstract Data Types (ADTs)

• _{ADT is a mathematically specifed entity that defnes a set of}

its instances, with:

• _{a specifc interface – a collection of signatures of methods that}

can be invoked on an instance,

• _{a set of axioms that defne the semantics of the methods (i.e.,}

Abstract Data Types (ADTs)

• _{Types of operations:}

• _Constructors

• _{Access functions}

• _{Manipulation procedures}

2012-2013 4

Abstract Data Types

• _{Why do we need to talk about ADTs in A&DS}

course?

• _{They serve as specifcations of requirements for}

the building blocks of solutions to algorithmic problems

• _{Provides a language to talk on a higher level of}

abstraction

• _{ADTs encapsulate data structures and algorithms}

2012-2013 5

Dynamic Sets

• _{We will deal with ADTs, instances of which are}

sets of some type of elements.

• _{The methods are provided that change the set}

2012-2013 6

Dynamic Sets (2)

• _{An example dynamic set ADT}

• _Methods:

• _New():ADT

• _{Insert(S:ADT, v:element):ADT} • _{Delete(S:ADT, v:element):ADT} • _{IsIn(S:ADT, v:element):boolean}

2012-2013 7

Dynamic Sets (3)

• _{Axioms that defne the methods:}

• _{IsIn(New(), v) = false}

• _{IsIn(Insert(S, v), v) = true}

• _{IsIn(Insert(S, u), v) = IsIn(S, v), if v ¹ u} • _{IsIn(Delete(S, v), v) = false}

2012-2013 8

Other Examples

• _{Other dynamic set ADTs:}

• _{Priority Queue}

• _Queue

2012-2013 9

Stacks

• _{A stack is a container of objects that are}

inserted and removed according to the

last-in-frst-out (LIFO) principle.

• Objects can be inserted at any time, but only the

last (the most-recently inserted) object can be removed.

• Inserting an item is known as “pushing” onto

the stack. “Popping” off the stack is

2012-2013 10

Stacks (2)

2012-2013 11

Stacks

• _{A stack is an ADT that supports three main}

methods:

• _{New():ADT – Creates a new stack}

• _{push(S:ADT, o:element):ADT - Inserts object o}

onto top of stack S

• _{pop(S:ADT):ADT - Removes the top object of stack} S; if the stack is empty an error occurs

• top(S:ADT):element – Returns the top object of

2012-2013 12

Stacks

• _{The following support methods should also be}

defned:

• _{size(S:ADT):integer - Returns the number of}

objects in stack S

• _{isEmpty(S:ADT): boolean - Indicates if stack S is}

empty

• _Axioms

13

Java stuff

•

Given the stack ADT, we need to code the ADT in order to

use it in the programs. You need to understand two

program constructs: interfaces and exceptions.

•

An interface is a way to declare what a class is to do. It

does not mention how to do it.

• For an interface, you just write down the method names and the parameters. When specifying parameters, what really matters is their types.

• Later, when you write a class for that interface, you actually code the content of the methods.

• _{Separating interface and implementation is a useful} programming technique.

14

A Stack Interface in Java

public interface

Stack

{

// accessor methods

public int

size();

public boolean

isEmpty();

public Object

top()

throws

StackEmptyException;

// update methods

public void

push

(Object

element);

public Object

pop()

throws

StackEmptyException;

}

(Note: Java has a built-in Stack utility class!)

Exceptions

•

Exceptions

are yet another programming

construct, useful for handling errors.

When we fnd an error (or an

exceptiona

l case), we just

throw

an

exception.

•

_{As soon as the exception is thrown, the}

flow of control exits from the current

method and goes to where that method

was called from

What is the point of

using exceptions?

.

•

We can delegate upwards the

responsibility of handling an error.

Delegating upwards means letting the

code who called the current code deal

the problem.

Throwing Exceptions back to calling

method

public void eatPizza() throws StomachAcheException

{ …..

if (ateTooMuch)

throw new StomachAcheException(“Ouch”);

…..}

Private void simulateMeeting()

{... Try

{TA.eatPizza();}

Catch (StomachAcheException e)

{system.out.println(“Somebody has a stomach ache”} ...}

 _{When the StomachAcheException is thrown we}

exit from the eatPizza() method and go back to where the method was called from.

 If no exception is thrown, processing continues

to the code after the catch block.

Exceptions

• _{Note that if somewhere in your method, you}

throw an exception, you need to add a throws clause next to your method name.

• _{If you never catch an exception, it will propagate}

upwards and upwards along the chain of method calls untill the user sees it.

• _{What exactly are exceptions in java? Classes.}

Public class StomachAcheException extends

RuntimeException{

public StomachAcheException (String err)

{super(err);} }

2012-2013 19

Array-Based Stack Implementation

•

Create a stack using an array by

specifying a maximum size

N

for

our stack.

•

The stack consists of an N-element

array

S

and an integer variable

t

,

the index of the top element in

array S.

•

Array indices start at 0, so we

20

Array-Based Stack in Java

public class ArrayStack implements Stack {

// Implementation of the Stack interface using an array.

public static final int CAPACITY = 1000

;

// default capacity of the stack

private int capacity;

// maximum capacity of the stack.

private Object S[ ];

// S holds the elements of the stack

private int t = -1;

// the top element of the stack.

public

ArrayStack( )

{

// Initialize the stack

this

(CAPACITY);//

with default capacity

}

public

ArrayStack

(int cap)

{

// Initialize the stack with given capacity

capacity = cap;

21

Array-Based Stack in Java (contd.)

public int

size( )

{

//Return the current stack size

return

(t + 1);

}

public boolean

isEmpty( )

{

// Return true iff the stack is empty

return

(t < 0);

}

public void

push(

Objec

t obj)

throws

StackFullException{

// Push a new element on the stack

if (

size()

== capacity) {

throw

new

StackFullException

(“

Stack overflow

.”);

}

S[++t] = obj;

}

22

Array-Based Stack in Java (contd.)

public Object

top( )// Return the top stack element

throws

StackEmptyException

{

if (

isEmpty( )

) {

throw new

StackEmptyException

(“Stack is empty.”);

}

return

S[t];

}

public Object

pop()

// Pop off the stack element

throws

StackEmptyException

{

if (isEmpty( )) {

23

Array-Based Stack in Java (contd.)

class StackFullException extends RunTimeException {

// don’t need anything in here!

}

class StackEmptyException extends RunTimeException {

// don’t need anything in here!

}

Array-based stack in Java

•

The array implementation is simple and efcient

(method performed in O(1)).

•

There is an upper bound, N, on the size of the

stack. The arbitrary value N may be too small for

given application, or a waste of memory.

•

StackEmptyException

is required by the

interface.

•

_{StackFullException}

_{is particular to this}

implementation.

25

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}

26

Method Stack in the JVM

•

The Java Virtual Machine (JVM)

keeps track of the chain of active

methods with a stack

•

When 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

•

Allows for

recursion

27

Application: Time Series

•

The

span s

_i

of a stock’s price on a certain day i is the

maximum number of consecutive days (up to the

current day) the price of the stock has been less than or

equal to its price on day i

28

An Inefcient Algorithm

•

There is a straightforward way to compute the span of a

stock on each of n days

:

The running time of this algorithm is (ugh!) O(n

2

). Why?

Algorithm computeSpans1(P):

Input: an n-element array P of numbers such that P[i] is the price of the stock on day i

29

A Stack Can Help

•

We see that s

_i

on day i can be easily computed if

we know the closest day preceding i, such that the

price is greater than on that day than the price on

day i. If such a day exists, let’s call it h(i),

otherwise, we conventionally defne h(i) = -1

•

The span is now computed as s

_i

= i- h(i)

We use a

stack to keep track of

h(i)

In the figure, h(3)=2,

h(5)=1 and h(6)=0.

What to do with the stack?

• _{What are possible values of h(7)?}

• _{Can it be 1 or 3 or 4?}

• _{No, h(7) can only be 2 or 5 or 6.}

2012-2013 30

• _{We store indices 2,5,6 in the stack.}

• _{To determine h(7) we compare the price on day 7}

with prices on day 6, day 5, day 2 in that order.

• _{The frst larger than the price on day 7 gives h(7)}

• _{The stack should be updated to reflect the price}

of day 7

• _{If the price on day 7 is larger than day 6 and less}

than day 5, the stack should now contain 2,5,7

31

An Efcient Algorithm

• _{The code for our new algorithm:}

Algorithm computeSpans2(P):

Input: an n-element array P of numbers representing stock prices Output: an n-element array S of numbers such that

S[i] is the span of the stock on day i Let D be an empty stack

for i 0 to n - 1 do k  0 done  false

A Growable Array-Based Stack

• _{Instead of giving up with a StackFullException,}

we can replace the array S with a larger one and continue processing push operations.

An Extendable Array

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

•

How large should the new array be?

•

tight strategy

(add a constant): f(N) = N + c

•

growth strategy

(double up): f(N) = 2N

Analyzing Extendable Array

Tight vs. Growth Strategies

•

To compare the two strategies, we use the following

cost model:

OPERATION

regular push operation:

special push operation: create an array of size f(N), copy N elements, and add one element

RUN TIME 1

f(N)+N+1

Tight Strategy (c=4)

• _{Starts with an array size 0. Cost of spesial push is 2N+5}

• _{Let see the ilustration}

36

Performance of the Tight Strategy

• In phase I the array has size c*I

• Total cost of phase I is

• _{C*I is the cost of creating the array}

• _{C*(i-1) is the cost of copying elements into new array} • _{C is the cost of the c pushes.}

• _{Hence, cost of phase I is 2ci}

• _{In each phase we do c pushes. Hence for n pushes we need}

n/c phases. Total cost of these n/c phases is

=

2c(1+2+3+…+n/c) ~ O(n

2

/c)

Growth Strategy

• _{Starts with an array size 0. Cost of spesial push is 3N+1}

• _{Let see the ilustration}

38

Performance of the Growth Strategy

• In phase I the array has size 2i

• Total cost of phase i is

• ₂i _{is the cost of creating the array}

• ₂i-1 _{is the cost of copying elements into new array}

• ₂i-1_{is the cost of the 2i-1 pushes done i n this phases}

• _{Hence, cost of phase i is 2}i+1

• _{If we do n pushes, we will have log n phases.}

• _{Total cost of these n pushes is}

=

2+4+8+…+2

logn+1

=4n-1

The growth strategy wins