1. Abstract Data Types (ADTs)
An abstract data type (ADT) is an abstraction of a data structure
An ADT specifies:
Data stored
Operations on the data
Error conditions associated with operations
11/13/13

2. The Stack ADT The Stack ADT stores arbitrary objects.
Insertions and deletions follow the last-in
first-out (LIFO) scheme.
The last item placed on the stack will
be the first item removed.
(similar to a stack of dishes)
Stack of Dishes
11/13/13

3. ADT Stack Operations Stack
Create an empty stack
Destroy a stack
Determine whether a stack is empty
Add a new item -- push
Remove the item that was added most recently -- pop
Retrieve the item that was added most recently
push
pop
top
Stack
11/13/13

4. ADT Stack Operations(cont.)
createStack()
creates a an empty stack
destroyStack()
destroys a stack
isEmpty():boolean
determines whether a stack is empty or not
push(in newItem:StackItemType) throw StackException
Adds newItem to the top of a stack
pop() throw StackException
pop(out stackTop:StackItemType) throw StackException
Removes the top of a stack (ie. removes the item that was added most recently
getTop(out stackTop:StackItemType) throw StackException
Retrieves the top of stack into stackTop
11/13/13

5. A Simple Stack Application -- Undo sequence in a text editor
Problem: abcd fg   abf
// Reads an input line. Enter a character or a backspace character ()
readAndCorrect(out aStack:Stack)
aStack.createStack()
read newChar
while (newChar is not end-of-line symbol) {
if (newChar is not backspace character)
aStack.push(newChar)
else if (!aStack.isEmpty())
aStack.pop() }
11/13/13

6. A Simple Stack Application -- Display Backward
Display the input line in reversed order by writing the contents of stack aStack.
displayBackward(in aStack:Stack)
while (!aStack.isEmpty())) {
aStack.pop(newChar)
write newChar }
11/13/13

7. Checking for Balanced Braces
A stack can be used to verify whether a program contains balanced braces
An example of balanced braces
abc{defg{ijk}{l{mn}}op}qr
An example of unbalanced braces
abc{def}}{ghij{kl}m
Requirements for balanced braces
Each time we encounter a “}”, it matches an already encountered “{”
When we reach the end of the string, we have matched each “{”
11/13/13

8. Checking for Balanced Braces -- Traces
11/13/13

9. Checking for Balanced Braces -- Algorithm
aStack.createStack(); balancedSoFar = true; i=0;
while (balancedSoFar and i < length of aString) {
ch = character at position i in aString; i++;
if (ch is ‘{‘) // push an open brace
aStack.push(‘{‘);
else if (ch is ‘}’) // close brace
if (!aStack.isEmpty())
aStack.pop(); // pop a matching open brace
else // no matching open brace
balancedSoFar = false;
// ignore all characters other than braces }
if (balancedSoFar and aStack.isEmpty())
aString has balanced braces
else
aString does not have balanced braces
11/13/13

10. Recognizing Strings in a Language
L = {w$w’ : w is a possible empty string of characters other than $,
w’ = reverse(w) }
abc$cba, a$a, $ are in the language L
abc$abc, a$b, a$ are not in the language L
Problem: Deciding whether a given string in the language L or not.
A solution using a stack
Traverse the first half of the string, pushing each character onto a stack
Once you reach the $, for each character in the second half of the string, match a popped character off the stack
11/13/13

11. Recognizing Strings in a Language -- Algorithm
aStack.createStack(); i=0; ch = character at position i in aString;
while (ch is not ‘$’) { // push the characters before $ (w) onto the stack
aStack.push(ch); i++; ch = character at position i in aString; }
i++; inLanguage = true; // skip $; assume string in language
while (inLanguage and i <length of aString) // match the reverse of
if (aStack.isEmpty()) inLanguage = false; // first part shorter than second part
else {
aStack.pop(stackTop); ch = character at position i in aString;
if (stackTop equals to ch) i++; // characters match
else inLanguage = false; // characters do not match
if (inLanguage and aStack.isEmpty())
aString is in language
else
aString is not in language
11/13/13

12. Implementations of the ADT Stack
The ADT stack can be implemented using
An array
A linked list
The ADT list
All three implementations use a StackException class to handle possible exceptions
11/13/13

13. Implementations of the ADT Stack (cont.)2 1
11/13/13

14. An Array-Based Implementation of the ADT Stack
Private data fields
An array of items of type StackItemType
The index top
Compiler-generated destructor and copy constructor
11/13/13

15. An Array-Based Implementation –Header File
#include "StackException.h"
const int MAX_STACK = maximum-size-of-stack;
typedef desired-type-of-stack-item StackItemType;
class Stack {
public:
Stack(); // default constructor; copy constructor and destructor are supplied by the compiler
// stack operations:
bool isEmpty() const; // Determines whether a stack is empty.
void push(StackItemType newItem) throw(StackException); // Adds an item to the top of a stack.
void pop() throw(StackException); // Removes the top of a stack.
void topAndPop(StackItemType& stackTop) throw(StackException);
void getTop(StackItemType& stackTop) const throw(StackException); // Retrieves top of stack.
private:
StackItemType items[MAX_STACK]; // array of stack items
int top; // index to top of stack };
11/13/13

16. An Array-Based Implementation isEmpty - push
#include "StackA.h" // Stack class specification file
Stack::Stack(): top(-1) {} // default constructor
bool Stack::isEmpty() const {
return top < 0; }
void Stack::push(StackItemType newItem) throw(StackException) {
// if stack has no more room for another item
if (top >= MAX_STACK-1)
throw StackException("StackException: stack full on push");
else {
items[++top] = newItem; }}
11/13/13

17. An Array-Based Implementation – pop
void Stack::pop() throw(StackException) {
if (isEmpty())
throw StackException("StackException: stack empty on pop");
else
--top; // stack is not empty; pop top }
void Stack::topAndPop(StackItemType& stackTop) throw(StackException) {
else { // stack is not empty; retrieve top
stackTop = items[top--]; }}
11/13/13

18. An Array-Based Implementation – getTop
void Stack::getTop(StackItemType& stackTop) const
throw(StackException) {
if (isEmpty())
throw StackException("StackException: stack empty on getTop");
else
// stack is not empty; retrieve top
stackTop = items[top]; }
11/13/13

19. An Array-Based Implementation – main
#include <iostream>
#include "StackA.h"
int main() {
StackItemType anItem;
Stack aStack;
cin >> anItem; // read an item
aStack.push(anItem); // push it onto stack
return 0; }
11/13/13

20. A Pointer-Based Implementation of the ADT Stack
Required when the stack needs to grow and shrink dynamically
top is a reference to the head of a linked list of items
A copy constructor and destructor must be supplied
11/13/13

21. A Pointer-Based Implementation – Header File
#include "StackException.h"
typedef desired-type-of-stack-item StackItemType;
class Stack{
public:
Stack(); // default constructor
Stack(const Stack& aStack); // copy constructor
~Stack(); // destructor
bool isEmpty() const;
void push(StackItemType newItem);
void pop() throw(StackException);
void topAndPop(StackItemType& stackTop) throw(StackException);
void getTop(StackItemType& stackTop) const throw(StackException);
11/13/13

22. A Pointer-Based Implementation – Header File
private:
struct StackNode { // a node on the stack
StackItemType item; // a data item on the stack
StackNode *next; // pointer to next node };
StackNode *topPtr; // pointer to first node in the stack
11/13/13

23. A Pointer-Based Implementation – constructor
#include "StackP.h" // header file
#include <cstddef> // for NULL
#include <cassert> // for assert
Stack::Stack() : topPtr(NULL) {} // default constructor
Stack::Stack(const Stack& aStack) { // copy constructor
if (aStack.topPtr == NULL)
topPtr = NULL; // original list is empty
else { // copy first node
topPtr = new StackNode; topPtr->item = aStack.topPtr->item;
// copy rest of list
StackNode *newPtr = topPtr; // new list pointer
for (StackNode *origPtr = aStack.topPtr->next; origPtr != NULL; origPtr = origPtr->next) {
newPtr->next = new StackNode;
newPtr = newPtr->next;
newPtr->item = origPtr->item; }
newPtr->next = NULL; }}
11/13/13

24. A Pointer-Based Implementation – destructor - isEmpty
Stack::~Stack() {
// pop until stack is empty
while (!isEmpty())
pop();
// Assertion: topPtr == NULL }
bool Stack::isEmpty() const {
return topPtr == NULL;
11/13/13

25. A Pointer-Based Implementation – push
void Stack::push(StackItemType newItem) {
// create a new node
StackNode *newPtr = new StackNode;
// set data portion of new node
newPtr->item = newItem;
// insert the new node
newPtr->next = topPtr;
topPtr = newPtr; }
11/13/13

26. A Pointer-Based Implementation – pop
void Stack::pop() throw(StackException) {
if (isEmpty())
throw StackException("StackException: stack empty on pop");
else { // stack is not empty; delete top
StackNode *temp = topPtr;
topPtr = topPtr->next;
// return deleted node to system
temp->next = NULL; // safeguard
delete temp; }
11/13/13

27. A Pointer-Based Implementation – pop
void Stack::topAndPop(StackItemType& stackTop) throw(StackException) {
if (isEmpty())
throw StackException("StackException: stack empty on pop");
else { // stack is not empty; retrieve and delete top
stackTop = topPtr->item;
StackNode *temp = topPtr;
topPtr = topPtr->next;
// return deleted node to system
temp->next = NULL; // safeguard
delete temp; }
11/13/13

28. A Pointer-Based Implementation – getTop
void Stack::getTop(StackItemType& stackTop) const
throw(StackException) {
if (isEmpty())
throw StackException("StackException: stack empty on getTop");
else
// stack is not empty; retrieve top
stackTop = topPtr->item; }
11/13/13

29. An Implementation That Uses the ADT List
The ADT list can be used to represent the items in a stack
If the item in position 1 is the top
push(newItem)
list.insert(newItem, list.zeroth());
pop()
list.remove(list.first().retrieve())
getTop(stackTop)
list.first().retrieve()
11/13/13

30. Comparing Implementations
Fixed size versus dynamic size
An array-based implementation
Prevents the push operation from adding an item to the stack if the stack’s size limit has been reached
A pointer-based implementation
Does not put a limit on the size of the stack
An implementation that uses a linked list versus one that uses a pointer-based implementation of the ADT list
Linked list approach is more efficient
ADT list approach reuses an already implemented class
Much simpler to write
Saves time
11/13/13

31. Application: Algebraic Expressions
When the ADT stack is used to solve a problem, the use of the ADT’s operations should not depend on its implementation
To evaluate an infix expression
Convert the infix expression to postfix form
Evaluate the postfix expression
Infix Expression Postfix Expression
5 + 2 * * +
5 * * 3 +
5 * ( ) * 4 -
11/13/13

32. Evaluating Postfix Expressions
When an operand is entered, the calculator
Pushes it onto a stack
When an operator is entered, the calculator
Applies it to the top two operands of the stack
Pops the operands from the stack
Pushes the result of the operation on the stack
11/13/13

33. Evaluating Postfix Expressions: 2 3 4 + *
11/13/13

34. Converting Infix Expressions to Postfix Expressions
An infix expression can be evaluated by first being converted into an equivalent postfix expression
Facts about converting from infix to postfix
Operands always stay in the same order with respect to one another
An operator will move only “to the right” with respect to the operands
All parentheses are removed
11/13/13

35. Converting Infix Expr. to Postfix Expr. -- Algorithm
for (each character ch in the infix expression) {
switch (ch) {
case operand: // append operand to end of postfixExpr
postfixExpr=postfixExpr+ch; break;
case ‘(‘: // save ‘(‘ on stack
aStack.push(ch); break;
case ‘)’: // pop stack until matching ‘(‘, and remove ‘(‘
while (top of stack is not ‘(‘) {
postfixExpr=postfixExpr+(top of stack); aStack.pop(); }
aStack.pop(); break;
11/13/13

36. Converting Infix Expr. to Postfix Expr. -- Algorithm
case operator: // process stack operators of greater precedence
while (!aStack.isEmpty() and top of stack is not ‘(‘ and
precedence(ch) <= precedence(top of stack) ) {
postfixExpr=postfixExpr+(top of stack);
aStack(pop); }
aStack.push(); break; // save new operator
} } // end of switch and for
// append the operators in the stack to postfixExpr
while (!isStack.isEmpty()) {
aStack(pop); }
11/13/13

37. Converting Infix Expressions to Postfix Expressions
a - (b + c * d)/ e  a b c d * + e / -
11/13/13

38. Application: A Search Problem
Problem: For each customer request, indicate whether a sequence of flights exists from the origin city to the destination city
The flight map is a directed graph
Adjacent vertices are two vertices that are joined by an edge
A directed path is a sequence of directed edges
A Flight Map
11/13/13

39. A Nonrecursive Solution That Uses a Stack
The solution performs an exhaustive search
Beginning at the origin city, the solution will try every possible sequence of flights until either
It finds a sequence that gets to the destination city
It determines that no such sequence exists
Backtracking can be used to recover from a wrong choice of a city
11/13/13

40. A Nonrecursive Solution -- Algorithm
searchS(in originCity:City, in destinationCity:City) : boolean
// searches for a sequence of flights from originCity to destinationCity
aStack.createStack();
clear marks on all cities;
aStack.push(originCity);
mark origin as visited;
while (!aStack.isEmpty() and destinationCity is not at top of stack) {
if (no flights exist from city on top of stack to unvisited cities)
aStack.pop(); // backtrack
else {
select an unvisited destination city C for a flight from city on top of stack;
aStack.push(C);
mark C as visited; }}
if (aStack.isEmpty()) return false; // no path exists
else return true; // path exists
11/13/13

41. A Nonrecursive Solution -- Trace
P is origin city; Z is destination city
11/13/13

42. A Recursive Solution for Search Problem
searchR(in originCity:City, in destinationCity:City):boolean
mark originCity as visited;
if (originCity is destinationCity)
Terminate -- the destination is reached
else
for (each unvisited city C adjacent to originCity)
searchR(C, destinationCity);
11/13/13

43. The Relationship Between Stacks and Recursion
A strong relationship exists between recursion and stacks
Typically, stacks are used by compilers to implement recursive methods
During execution, each recursive call generates an activation record that is pushed onto a stack
Stacks can be used to implement a nonrecursive version of a recursive algorithm
11/13/13

44. C++ Run-time Stack
main i = 5
foo j = 5
k = 6
bar m = 6
The C++ run-time system keeps track of the chain of active functions with a stack
When a function is called, the run-time system pushes on the stack a frame containing
Local variables and return value
When a function returns, its frame is popped from the stack and control is passed to the method on top of the stack
main() { int i = 5; foo(i); }
foo(int j) { int k; k = j+1; bar(k); }
bar(int m) { … }
Run-time Stack
11/13/13

45. Example: Factorial function
int fact(int n) {
if (n ==0)
return (1);
else
return (n * fact(n-1)); }
11/13/13

46. Tracing the call fact (3)
if (N==0) true
return (1)
N = 1
if (N==0) false
return (1*fact(0))
N = 2
return (2*fact(1))
N = 3
return (3*fact(2))
After 3rd call
N = 3
if (N==0) false
return (3*fact(2))
After original call
N = 2
if (N==0) false
return (2*fact(1))
N = 3
return (3*fact(2))
After 1st call
N = 1
if (N==0) false
return (1*fact(0))
N = 2
return (2*fact(1))
N = 3
return (3*fact(2))
After 2nd call
11/13/13

47. Tracing the call fact (3)
if (N==0) false
return (3* 2)
After return from 1st call
return 6
N = 1
if (N==0) false
return (1* 1)
N = 2
return (2*fact(1))
N = 3
return (3*fact(2))
After return from 3rd call
N = 2
if (N==0) false
return (2* 1)
N = 3
return (3*fact(2))
After return from 2nd call
11/13/13

48. Stacks -- Summary
ADT stack operations have a last-in, first-out (LIFO) behavior
There are different stack implementations
Two Major Implementations: Array-Based, Pointer-Based
Many stack applications
expression processing
language recognition
search problem
A strong relationship exists between recursion and stacks
Any recursive program can be rewritten as a nonrecursive program using stacks.
11/13/13