A stack is a linear, homogeneous, container that stores and dispenses
its content in a LIFO manner.!
LIFO -!
!The last (most recent) item inserted, and not yet removed, will!
! be the first (next) item dispensed.!
Real World Examples!
• a spring-loaded cafeteria tray dispenser.!
• a driveway wide that is one-car wide!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
Stack Operations!
push!
insert a new item into the stack!
pop!
remove one item from the container!
top!
inspect one item from the container, but don’t remove it!
An Abstract Picture!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
1
(i.e. the class specification)!
Stack<ItemType>
Domain
sequence of ItemType!
Constructor
public Stack()!
post: this == sequence{}
Query methods
public boolean isEmpty()!
!post: result == (this->size() == 0)
public ItemType top()!
!pre: ! isEmpty()
post: result == this->first()
Update methods
!!
public void push(ItemType z)!
!post: this == this@pre->prepend(z) !
public void pop()!
!pre: ! isEmpty() (throws java.util.EmptyStackException)
post: this == this@pre->subSequence( 2, this@pre->size() )
Example!
Stack<ItemType>
Stack<String> s1, s2;
String str;
+
+
+
+
+
s1 = new Stack<String>();
s1.push( “humble” );
s1.push( “bumble” );
s1.push( “mumble” );
s1.pop();
s1.push( “tumble” );
str = (String) s1.top();
s1.push( “rumble” );
s1.push( “crumble” );
s1.pop();
s1.pop();
s1.push( s1.top() );
s2 = new Stack();
while ( !s1.isEmpty() )
s2.push( s1.top() );
s1.pop();
}
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
Stack()
boolean isEmpty()
void push(ItemType z)
void pop()
ItemType top()
{
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
2
How would you represent ...!
... a bounded stack?!
... an unbounded stack?!
Would you use inheritance or aggregation?!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
public class Stack<ItemType>
!private SimplerSingleList<ItemType> theList;
!/** post: !theList.isEmpty() */!
!public Stack()
}!
{
theList = new SimplerSingleList<ItemType>();
!/* * post: !result == theList.isEmpty() */!
!public boolean isEmpty()
}!
return
!/** post:
{
theList.isEmpty();
!theList == theList@pre with z appended to front*/!
!public void push(ItemType
}!
z)
theList.start();
theList.insertBefore(z);
{
!//continued …!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
3
!/** pre: !! theList.isEmpty()!
! * post: !theList == theList@pre with first item removed */!
!public void pop()
}
{
theList.start();
theList.removeAt();
!/** pre: !! theList.isEmpty()!
! * post: !result == first item of theList */!
!public ItemType top()
}
{
theList.start();
return theList.item();
}!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
• Each method call causes an activation record (local variables & !
parameters) to be pushed upon the run-time stack.!
• When a method returns its activation record is popped off the !
run-time stack.!
• Each time the compiler encounters a { it is pushed upon the parse stack.!
• Each time the compiler encounters a } it is pops the matching } from the !
parse stack.!
The finite state machine can be augmented by adding a stack. Such a device
is called a push-down automaton. !
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
4
Stacks are useful for evaluating many kinds of expressions.!
Reverse Polish notation !
In Reverse Polish Notation (RPN) operands occur before their associated
operator, and operators occur as soon as possible. (Also called _____________.)!
Rules:!
!1) Operands occur left-to-right in the same order as infix expression!
!2) Operation follows immediately after its operand/subexpression!
Examples!
Infix
!
!
!
7 - 3!
!
!RPN!
7, 3, -!
8 * 4 + 5!
1 + (2*3) - 4!
((9+8)*7)-(6*(5+(4/3)))!
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
Scan expression left to right, and…!
For each operand - push!
For each operator - replace two top operands by their subexpression value!
!(Note: top of stack is right operand, second in stack is left.)!
Example!
9, 8, +, 7, *, 6, 5, 4, 3, /, +, *, -!
OperandStack !
The Object of Data Abstraction
and Structure, David D. Riley
© Addison Wesley pub.
5