1. Stacks (and Queues)

2. Stacks
Stack: what is it?
ADT
Applications
Implementation(s)

3. Stacks and queues
A stack is a very important data structure in computing science.
A stack is a sequence of elements to which new elements are added (pushed), and from which elements are removed (popped), at the same end.
Stack sometimes referred to as a last in, first out structure (LIFO).
In a queue, elements are removed from the opposite end to which they are added.
Queue sometimes referred to as a first in, first out structure (FIFO).

4. Stacks and queues
The difference is the remove operation.
add
remove

5. Last In First Out B A C B A D C B A E D C B A top D C B A top top top

6. Abstract Data Types (ADTs)
An abstract data type (ADT) is an abstraction of a data structure
An 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

7. The Stack ADT The Stack ADT stores arbitrary objects
Insertions and deletions follow the last-in first-out scheme
Think of a spring-loaded plate dispenser. (Pez?)

8. The Stack ADT Main stack operations: Auxiliary stack operations:
push(object): inserts an element
Object pop(): removes and returns the last inserted element
Auxiliary stack operations:
Object peek(): returns the last inserted element without removing it. (Sometimes appears as Object top())
integer size(): returns the number of elements stored
boolean isEmpty(): indicates whether no elements are stored
WHICH ONES ARE ACCESSOR OR MUTATOR METHODS???

9. Stack Operations Assume a simple stack for integers.
Stacks
Stack Operations
Assume a simple stack for integers.
Stack s = new Stack();
s.push(12);
s.push(4);
s.push( s.top() + 2 );
s.pop()
s.push( s.top() );
//what are contents of stack?
CSCU9A3

10. Stack usage and limitations
Stacks
Stack usage and limitations
Write an algorithm to Reverse the contents of an array. How about using a stack?
Write a method to print out contents of stack in reverse order.
CSCU9A3

11. Stack Interface in Java
public interface Stack<E> {
public int size();
public boolean isEmpty();
public Object top() throws EmptyStackException;
public void push(E element);
public Object pop() throws EmptyStackException; }
Java interface corresponding to our Stack ADT
Requires the definition of class EmptyStackException
Different from the built-in Java class java.util.Stack

12. Exceptions
Attempting the execution of an operation of ADT may sometimes cause an error condition, called an exception
Exceptions 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 empty
Attempting the execution of pop or top on an empty stack throws an EmptyStackException

13. 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

14. 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
Local variables and return value
Program counter, keeping track of the statement being executed
When a method ends, it’s 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

15. Array-based Stack Allocate an array of some size (pre-defined)
Maximum N elements in stack
Bottom stack element stored at element 0
last index in the array is the top
What is index when stack is empty?
Increment top when one element is pushed, decrement after pop

16. Array-based Stack Algorithm size() return top + 1 Algorithm pop()
if isEmpty() then
throw EmptyStackException
else
top  top  1
return S[top + 1] … S 1 2 t

17. Array-based Stack (cont.)
The array storing the stack elements may become full
A push operation will then throw a FullStackException
Limitation of the array-based implementation
Not intrinsic to the Stack ADT
Algorithm push(o)
if t = S.length  1 then
throw FullStackException
else
t  t + 1
S[t]  o S 1 2 t …

18. Performance and Limitations
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

19. Common Stack Error Stack s = new Stack(); // put stuff in stack
for(int i = 0; i < 7; i++)
s.push( i );
// print out contents of stack
// while emptying it
for(int i = 0; i < s.size(); i++)
System.out.println( s.pop() );
// Output? Why?
CSCU9A3

20. Corrected Version Stack s = new Stack(); // put stuff in stack
for(int i = 0; i < 7; i++)
s.push( i );
// print out contents of stack
// while emptying it
int limit = s.size();
for(int i = 0; i < limit; i++)
System.out.println( s.pop() );
//or
// while( !s.isEmpty() )
// System.out.println( s.pop() );
CSCU9A3

21. Array-based Stack in Java
public class ArrayStack<E> implements Stack<E> {
// holds the stack elements private E S[ ];
// index to top element private int top = -1;
// constructor public ArrayStack(int capacity) { S = (E[]) new
Object[capacity]); }
public E pop() throws
EmptyStackException { if isEmpty() {
throw new EmptyStackException (“Empty stack: cannot pop”); }
E temp = S[top];
// facilitate garbage collection: S[top] = null;
top = top – 1; return temp; }
… (other methods of Stack interface)

22. Example use in Java public class Tester {
// … other methods
public void intReverse(Integer a[]) { Stack<Integer> s;
s = new ArrayStack<Integer>();
for(int i = 0; i < a.length; a++)
s.push(a[i]);
a[i] = s.pop(); }
public void floatReverse(Float f[]) { Stack<Float> s;
s = new ArrayStack<Float>();
… (code to reverse array f) … }

23. Parentheses Matching
Each “(”, “{”, or “[” must be paired with a matching “)”, “}”, or “[”
correct: ( )(( )){([( )])}
correct: ((( )(( )){([( )])}
incorrect: )(( )){([( )])}
incorrect: ({[ ])}
incorrect: (

24. Parentheses Matching Algorithm
Algorithm ParenMatch(X,n):
Input: An array X of n tokens, each of which is either a grouping symbol, a variable, an arithmetic operator, or a number
Output: true if and only if all the grouping symbols in X match
Let S be an empty stack
for i=0 to n-1 do
if X[i] is an opening grouping symbol then
S.push(X[i])
else if X[i] is a closing grouping symbol then
if S.isEmpty() then
return false {nothing to match with}
if S.pop() does not match the type of X[i] then
return false {wrong type}
return true {every symbol matched}
else return false {some symbols were never matched}

25. HTML Tag Matching The Little Boat
For fully-correct HTML, each <name> should pair with a matching </name>
<body>
<center>
<h1> The Little Boat </h1>
</center>
<p> The storm tossed the little
boat like a cheap sneaker in an
old washing machine. The three
drunken fishermen were used to
such treatment, of course, but
not the tree salesman, who even as
a stowaway now felt that he
had overpaid for the voyage. </p>
<ol>
<li> Will the salesman die? </li>
<li> What color is the boat? </li>
<li> And what about Naomi? </li>
</ol>
</body>
The Little Boat
The storm tossed the little boat
like a cheap sneaker in an old
washing machine. The three
drunken fishermen were used to
such treatment, of course, but not
the tree salesman, who even as
a stowaway now felt that he had
overpaid for the voyage.
1. Will the salesman die?
2. What color is the boat?
3. And what about Naomi?

26. Infix notation Consider the arithmetic expression:
3 + 4 * (5 - 2)
Binary operators requires two operands.
To evaluate the expression, we use the following rules:
* and / have higher precedence than + and -,
when operators have the same precedence, we apply them from left to right,
brackets change the order of precedence.
Hence the following example gives a different answer:
3 + 4 * (3 - 1)
Consider a system of arithmetic with different rules…

27. Reverse Polish
With reverse Polish (postfix) notation, no precedence rules or parentheses required!
In postfix notation, we put the operator after its operands instead of between them.
Hence, instead of 5 + 4, we have

28. Postfix Notation The first expression above, would be re-written as:
3 + 4 * (5 - 2)
* –
while the second would be written as:
3 + 4 * (3 - 1)
3 4 5 *
The operands are written in the same order while the operators are now written in the order in which they are to be applied.

29. Evaluating Postfix Expressions

30. Examples Let us first apply it to our simple example: 5 4 +
Stacks
Examples
Let us first apply it to our simple example: 5 4 +
Answer is 9
Next ‘Token’: 5 4 +
With the expression: *
Next - * 5 4 5 9 2 5 4 3 3 4 12 3 15 3 15 12 1 12 11
CSCU9A3