Download Stacks

Stacks
Stack ADT
A stack is a data structure that holds a sequence of
elements and stores and retrieves items in a last-in firstout manner (LIFO).
This means that when a program retrieves an item from a
stack, the last item inserted into the stack is the first one
retrieved.
Similarly, the first item inserted is the last one retrieved
(FILO).
Stack ADT
5
4
3
2
1
Last plate in, first plate out
first plate in, last plate out
Stack of
Plates
The stack is a common data structure for representing things
that need to maintained in a particular order. For instance,
when a function calls another function, which in turn calls a
third function, it's important that the third function return back
to the second function rather than the first.
Static and Dynamic Stacks
There are two kinds of stack data structure a) static, i.e. they have a fixed size, and are
implemented as arrays.
b) dynamic, i.e. they grow in size as needed, and
implemented as linked lists.
push() and pop()
A stack has two primary operations, called push and pop.
a) The push operation causes a value to be stored (pushed) onto the
stack.
e.g. if we have an empty integer stack with maximum capacity of
3 items, we can perform the following 3 push operations push(5);
push(10);
push(15);
push() and pop()
The pop operation retrieves (removes) an item from the
stack.
If we execute 3 consecutive pop operations on the stack as
shown above, we get the following results -
Exceptions




Attempting the execution of an operation of an 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, operation pop cannot be
performed if the stack is empty
In the Stack ADT, operation push cannot be
performed if the stack is full
Attempting the execution of pop on an empty stack,
or a push on a full stack, throws an
EmptyStackException
Stack Operations
Therefore, in order to simulate a stack
functionality, the following operations need to be
implemented.
–
Main stack operations:


–
push(object o): inserts element o
pop(): removes and returns the last inserted element
Auxiliary stack operations:



top(): returns a reference to the last inserted element
without removing it
size(): returns the number of elements stored
isEmpty(): returns a Boolean value indicating whether no
elements are stored
Applications of Stacks

Direct applications
–
–
–

Page-visited history in a Web browser
Undo sequence in a text editor
Saving local variables when one function calls
another, and this one calls another, and so on.
Indirect applications
–
–
Auxiliary data structure for algorithms
Component of other data structures
C++ Run-time Stack



The C++ run-time system keeps
track of the chain of active functions
with a stack
When a function is called, the runtime system pushes on the stack a
frame containing
main() {
int i = 5;
foo(i);
}
foo(int j) {
– Local variables and return value
int k;
– Program counter, keeping track of
k = j+1;
the statement being executed
bar(k);
When a function returns, its frame is
}
popped from the stack and control is
passed to the method on top of the
bar(int m) {
stack
…
}
bar
PC = 1
m=6
foo
PC = 3
j=5
k=6
main
PC = 2
i=5
Array-based Stack



A simple way of
implementing the
Stack ADT uses an
array
We add elements
from left to right
A variable keeps
track of the index of
the top element
Algorithm size()
return t + 1
Algorithm pop()
if isEmpty() then
throw EmptyStackException
else
tt1
return S[t + 1]
…
S
0 1 2
t
Array-based Stack (cont.)


The array storing the
Algorithm push(o)
stack elements may
become full
if t = S.length  1 then
A push operation will then
throw FullStackException
throw a
else
FullStackException
–
–
Limitation of the arraybased implementation
Not intrinsic to the Stack
ADT
tt+1
S[t]  o
…
S
0 1 2
t
Performance and Limitations

Performance
–
–
–

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
Writing a program that uses an
STL stack
Using a Stack in a Program

Requirement
–

Reverse a phrase that is input by the user
Steps in the process of creating the program
1. Write a test
2. Write an algorithm
3. Write the program
4. Test the program

Run an automated test – one way to test your
program
1. Write a Test
Reverse "Go dog"
Reverse "Madam, I’m Adam"
2. Write an Algorithm
//ALGORITHM main()
// Get the string s1
// Reverse the string
// Print the reversed string
2. Write an Algorithm
//ALGORITHM main()
// Get the string s1
// Use a stack to reverse the string
//
reverseString(s1)
// Print the reversed string
2. Write an Algorithm
ALGORITHM reverseString(s1)
Input: a string
Output: the string reversed
2. Write an Algorithm
ALGORITHM reverseString(s1)
Input: a string
Output: the string reversed
string s2
stack st
for i = 0 to i = s1.length - 1
st.push(s1[i])
while not st.empty()
s2 += st.top()
st.pop()
return s2
Implementing a Data Structure
as a Class
A Stack Example
Stack ADT
int size()
Return the number of elements in the stack
bool isEmpty()
Indicate whether the stack is empty
void push( Object element )
Insert element at the top of the stack
Object top()
Return the top element on the stack without removing it; an
error occurs if the stack is empty.
Object pop()
Remove and return the top element on the stack; an error
occurs if the stack is empty
To begin…

Open a header file and name it “ArrayStack.h”

Write the keyword “class” followed by the name of the
class
class ArrayStack {
};
Add the curly braces, and
remember the semicolon
Step 1 – Declare Public Operations

Declare member functions for all the public operations that
are called for by the ADT
(See p. 157 for the stack ADT.)
class ArrayStack {
public:
Access specifier
int size();
bool isEmpty();
void push( const char& c );
char& top();
void pop();
};
All member functions after
“public:” are accessible
by any client in your
program wherever there is
an object of this class.
Step 2 – Declare Data Members

Next, decide how to hold the data that the data structure
will contain. For example, you could put it into either an
array or a linked list.
All members after
“private:” are only
Access specifier accessible to the member
functions of this class.
class ArrayStack {
private:
int capacity;//Maximum capacity of the array
char *pMyArray;//Pointer to an array
Information hiding
public:
int size();
Data members are always “private”
so that the object’s client cannot change
bool isEmpty();
void push(const char& c); the data by accessing it directly.
Data can be accessed only by using the
char& top();
“public” member functions.
void pop();
};
Step 3 – Define the Operations

Now, decide how to implement the operations
class ArrayStack {
private:
int topIndex;
int capacity; //Maximum capacity of the array
char *pMyArray; //Pointer to an array
public:
int size();
bool isEmpty();
void push(const char& c);
char& top() { return pMyArray[topIndex]; }
void pop();
};
Step 4 – Add Exceptions etc.


Add robustness – use exceptions
Avoid memory problems
–
–
Implement a copy constructor
Implement operator=