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 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
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=n-1

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

Data Structures Stacks

15

Application: Infix to Postfix

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

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 (in-stack
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 One-Dimensional Array

Two Stacks in a Vector S

Data Structures Stacks

20

Advanced Topic:
Multiple Stacks

Multiple Stacks in One-Dimensional 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]
= n-1
Top addresses, T(i)
T[i] = B[i] ,

0im

Data Structures Stacks

21

Advanced Topic:
Multiple Stacks

Multiple Stacks using One-Dimensional 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 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

Advanced Topic:
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

Advanced Topic:
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

Advanced Topic:
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.");

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 m-1:
= + + diff[j-1]
B[j] = B[j-1] + size[j-1] +
=
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 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