You are on page 1of 31

# 2 Stacks

## Data Structures Stacks

Objectives
At the end of the lesson, the student should be able to:

## Explain the basic concepts and operations on the ADT

stack
representation
Discuss applications of stack: the pattern recognition
problem and conversion from infix to postfix
Explain how multiple stacks can be stored using onedimensional array
Reallocate memory during stack overflow in multiple-stack
array using unit-shift policy and Garwick's algorithm
Data Structures Stacks

Introduction

## Stack - linearly ordered set of elements having the last-in,

first-out (LIFO) discipline
Operations are done on top of the stack only and we have

Operations

Operations

Push

Pop

## Data Structures Stacks

Operations
public interface Stack{
public int size(); /* returns the size of the stack */
public boolean isEmpty(); /* checks if empty */
public Object top() throws StackException;
public Object pop() throws StackException;
public void push(Object item) throws StackException;
}
class StackException extends RuntimeException{
public StackException(String err){
super(err);
}
}

## Data Structures Stacks

Implementations

Sequential Representation

## Data Structures Stacks

Implementations
public class ArrayStack implements Stack{
public static final int CAPACITY = 1000;
public int capacity;
Object S[];
int top = -1;
public ArrayStack(){
this(CAPACITY);
}
public ArrayStack(int c){
capacity = c;
S = new Object[capacity];
}
public int size(){
return (top+1);
}
public boolean isEmpty(){
return (top < 0);
}
Data Structures Stacks

Implementations
public Object top(){
if (isEmpty()) throw new StackException("Stack empty.");
return S[top];
}
public Object pop(){
Object item;
if (isEmpty()) throw new StackException("Stack underflow.");
item = S[top];
S[top--] = null;
return item;
}
public void push(Object item){
if (size()==capacity)
throw new StackException("Stack overflow.");
S[++top]=item;
}

Implementations

10

Implementations

## public class LinkedStack implements Stack{

private Node top;
private int numElements = 0;
public int size(){
return (numElements);
}
public boolean isEmpty(){
return (top == null);
}
public Object top(){
if (isEmpty())
throw new StackException("Stack empty.");
}

## Data Structures Stacks

11

Implementations
public Object pop(){
Node temp;
if (isEmpty())
throw new StackException("Stack underflow.");
temp = top;
return temp.info;
}

## public void push(Object item){

Node newNode = new Node();
newNode.info = item;
top = newNode;
}
}

## Data Structures Stacks

12

Application: Pattern
Recognition Problem

## Given an inifinite set of palindrome strings L = { wcw R | w { a, b }+ }, where wR

is the reverse of w and w may not be the empty string

1.Get next character a or b from input string and push onto the stack; repeat
until the symbol c is encountered.

2.Get next character a or b from input string, pop stack and compare. If the
two symbols match, continue; otherwise, stop the string is not in L.
Additional states where the input string is not in L:
1.The end of the string is reached but no c is encountered.
2.The end of the string is reached but the stack is not empty.
3.The stack is empty but the end of the string is not yet reached.

## Data Structures Stacks

13

Application: Pattern
Recognition Problem

Example
Input
abbabcbabba
abbabcbabba
bbabcbabba
babcbabba
abcbabba
bcbabba
cbabba
babba
abba
bba
ba
a
-

Action
-----Push a
Push b
Push b
Push a
Push b
Pop, compare b and b --> ok
Pop, compare a and a --> ok
Pop, compare b and b --> ok
Pop, compare b and b --> ok
Pop, compare a and a --> ok
Success
Data Structures Stacks

Stack
(bottom) --> (top)
a
ab
abb
abba
abbab
abbab
abba
abb
ab
a
-

14

## infix form - every subexpression is of the form operand-operatoroperand

postfix form - every subexpression is of the form operand-operandoperator, form most appropriate for computers

Some properties:

## degree of an operator - number of operands it has

the rank of an operand is 1, the rank of an operator is 1 minus its
degree, the rank of an arbitrary sequence of operands and operators is
the sum of the ranks of the individual operands and operators
if z = x | y is a string, then x is the head of z. x is a proper head if y is
not the null string

15

## Theorem: A postfix expression is well-formed iff the rank of

every proper head is greater than or equal to 1 and the rank
of the expression is 1.

Operator
^
*/
+-

Priority
3
2
1

Property
right associative
left associative
left associative

Example
a^b^c = a^(b^c)
a*b*c = (a*b)*c
a+b+c = (a+b)+c

16

## Rules in converting from infix to postfix:

1.Order of the operands in both forms is the same whether
or not parentheses are present in the infix expression
2.If the infix expression contains no parentheses, then the
order of the operators in the postfix expression is
according to their priority
3.If the infix expression contains parenthesized
subexpressions, rule 2 applies for such subexpression

17

## Application: Infix to Postfix

Priority numbers:

## icp(x) - priority number when token x is an incoming symbol

(incoming priority)
isp(x) - priority number when token x is in the stack (in-stack
priority)

Token, x
Operand
+*/
^
(

icp(x)
0
1
3
6
7

isp(x)
2
4
5
0

Rank
1
-1
-1
-1
18

## Application: Infix to Postfix

The algorithm:
1. Get the next token x.
2. If x is an operand, then output x.
3. If x is the ( , then push x onto the stack.
4. If x is the ), then output stack elements until an ( is
encountered. Pop stack once more to delete the (. If top = 0,
the algorithm terminates.
5. If x is an operator, then while icp(x) < isp(stack(top)),
output stack elements; else, if icp(x) > isp(stack(top)),
then push x onto the stack.
6. Go to step 1.

19

Multiple Stacks

20

Multiple Stacks

## Three or More Stacks in a Vector S

Base pointers, B(i) - defines the start of m stacks in a vector S with size
n. B[i] points to the space one cell below the stack's first actual cell:
B[i]
= n/m * i - 1
0i<m
B[m]
= n-1
T[i] = B[i] ,

0im

21

Multiple Stacks

22

Multiple Stacks

## Multiple Stacks using One-Dimensional Array

/* Pushes element on top of stack i */
public void push(int i, Object item) {
if (T[i]==B[i+1]) MstackFull(i);
S[++T[i]]=item;
}
/* Pops the top of stack i */
public Object pop(int i) throws StackException{
Object item;
if (isEmpty(i))
throw new StackException("Stack underflow.");
item = S[T[i]];
S[T[i]--] = null;
return item;
}
Data Structures Stacks

23

Multiple Stacks

## Reallocating Memory at Stack Overflow

Unit-shift method
void unitShift(int i) throws StackException{
int k=-1;
/* Points to the 'nearest' stack w/
free space*/
/*Scan stacks above the overflowed stack*/
for (int j=i+1; j<m; j++)
if (T[j] < B[j+1]) {
k = j;
break;
}

## /* Shift items of stack k to make room at stack i */

if (k > i){
for (int j=T[k]; j>T[i]; j--)
S[j+1] = S[j];
Data Structures Stacks

24

Multiple Stacks

## Reallocating Memory at Stack Overflow

Unit-shift method

## /* Adjust top and base pointers */

for (int j=i+1; j<=k; j++) {
T[j]++;
B[j]++;
}

## /*Scan the stacks below if none is found above */

else if (k > 0){
for (int j=i-1; j>=0; j--)
if (T[j] < B[j+1]) {
k = j+1;
break;
}
Data Structures Stacks

25

Multiple Stacks

## Reallocating Memory at Stack Overflow

Unit-shift method

## for (int j=B[k]; j<=T[i]; j++)

S[j-1] = S[j];
/* Adjust top and base pointers */
for (int j=i; j>k; j--) {
T[j]--;
B[j]--;
}
}
else
/* Unsuccessful, every stack is full */
throw new StackException("Stack overflow.");

26

Multiple Stacks

## Reallocating Memory at Stack Overflow

Garwick's algorithm

## remaining space is distributed to the stacks based on the current need

Knuth's implementation:
1) Gather statistics on stack usage
stack sizes = T[j] - B[j]
(+1 if the stack that overflowed)
differences= T[j] oldT[j]
if T[j] oldT[j] >0,
else 0 [Negative diff is replaced with 0]
(+1 if the stack that overflowed)
freecells= total size (sum of sizes)
incr= (sum of diff)
Data Structures Stacks

27

Multiple Stacks

## Garwick's algorithm (Knuth's implementation):

2) Calculate the allocation factors
= 10% * freecells / m
= 90%* freecells / incr
where
m = number of stacks
- no. of cells each stack gets from 10% of available
space allotted
- no. of cells the stack will get per unit increase in
stack usage from the remaining 90% of free space
3) Compute the new base addresses
- free space theoretically allocated to stacks 0, 1, 2, ..., j 1
- free space theoretically allocated to stacks 0, 1, 2, ..., j
*actual no. of whole free cells allocated to stack j =
Data Structures Stacks

28

Multiple Stacks

## Garwick's algorithm (Knuth's implementation):

Initially, (new)B[0] = -1 and = 0
for j = 1 to m-1:
= + + diff[j-1]
B[j] = B[j-1] + size[j-1] +
=
4) Shift stacks to their new boundaries
Set oldT = T

29

Multiple Stacks

## Stacks After Reallocation

Data Structures Stacks

30

Summary

## A stack is a linearly ordered set of elements obeying the last-in,

first-out (LIFO) principle
Two basic stack operations are push and pop
Stacks have two possible implementations a sequentially
allocated one-dimensional array (vector) or a linked linear list
Stacks are used in various applications such as pattern
recognition, lists and tree traversals, and evaluation of
expressions
Two or more stacks coexisting in a common vector results in
better memory utilization
Memory reallocation techniques include the unit-shift method and
Garwick's algorithm
Data Structures Stacks

31