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
Implement the ADT stack using sequential and linked
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 multiplestack
array using unitshift policy and Garwick's algorithm
Data Structures Stacks
Introduction
Stack  linearly ordered set of elements having the lastin,
firstout (LIFO) discipline
Operations are done on top of the stack only and we have
no access to other elements
Basic operations: push and pop
Representation: sequential or linked
Data Structures Stacks
Operations
Insertion of new element onto the stack (push)
Deletion of the top element from the stack (pop)
Getting the size of stack
Checking for empty stack
Getting the top element without deleting it from the stack
Data Structures Stacks
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
Makes use of arrays
Stack is empty if top=1 and full if top=n1
Deletion from an empty stack causes an underflow
Insertion onto a full stack causes an overflow
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;
}
Data Structures Stacks
Implementations
Linked Representation
A linked list of stack nodes could be used to implement a stack
Data Structures Stacks
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.");
return top.info;
}
Data Structures Stacks
11
Implementations
public Object pop(){
Node temp;
if (isEmpty())
throw new StackException("Stack underflow.");
temp = top;
top = top.link;
return temp.info;
}
public void push(Object item){
Node newNode = new Node();
newNode.info = item;
newNode.link = top;
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
Discard c
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
Application: Infix to Postfix
Expressions can be in:
infix form  every subexpression is of the form operandoperatoroperand
postfix form  every subexpression is of the form operandoperandoperator, 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
Data Structures Stacks
15
Application: Infix to Postfix
Theorem: A postfix expression is wellformed 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
Data Structures Stacks
Example
a^b^c = a^(b^c)
a*b*c = (a*b)*c
a+b+c = (a+b)+c
16
Application: Infix to Postfix
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
Data Structures Stacks
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 (instack
priority)
Token, x
Operand
+*/
^
(
icp(x)
0
1
3
6
7
isp(x)
2
4
5
0
Data Structures Stacks
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.
Data Structures Stacks
19
Advanced Topic:
Multiple Stacks
Multiple Stacks using OneDimensional Array
Two Stacks in a Vector S
Data Structures Stacks
20
Advanced Topic:
Multiple Stacks
Multiple Stacks in OneDimensional Array
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]
= n1
Top addresses, T(i)
T[i] = B[i] ,
0im
Data Structures Stacks
21
Advanced Topic:
Multiple Stacks
Multiple Stacks using OneDimensional Array
Three Possible States of a Stack  Stack i is:
full if T[i] = B[i+1]
not full if T[i] < B[i+1]
empty if T[i] = B[i]
Data Structures Stacks
22
Advanced Topic:
Multiple Stacks
Multiple Stacks using OneDimensional 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
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Unitshift 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
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Unitshift 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=i1; j>=0; j)
if (T[j] < B[j+1]) {
k = j+1;
break;
}
Data Structures Stacks
25
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Unitshift method
for (int j=B[k]; j<=T[i]; j++)
S[j1] = 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.");
Data Structures Stacks
26
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Garwick's algorithm
a fixed amount of space is divided among all the stacks
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
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
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
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Garwick's algorithm (Knuth's implementation):
Initially, (new)B[0] = 1 and = 0
for j = 1 to m1:
= + + diff[j1]
B[j] = B[j1] + size[j1] +
=
4) Shift stacks to their new boundaries
Set oldT = T
Data Structures Stacks
29
Advanced Topic:
Multiple Stacks
Reallocating Memory at Stack Overflow
Garwick's algorithm (Knuth's implementation):
Stacks Before Reallocation
Stacks After Reallocation
Data Structures Stacks
30
Summary
A stack is a linearly ordered set of elements obeying the lastin,
firstout (LIFO) principle
Two basic stack operations are push and pop
Stacks have two possible implementations a sequentially
allocated onedimensional 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 unitshift method and
Garwick's algorithm
Data Structures Stacks
31