1) Stacks are last-in, first-out (LIFO) data structures that allow efficient insertion and removal of elements from only one end, called the top. Common stack operations are push and pop. 2) Stacks have many applications, including checking for balanced brackets in code, evaluating postfix expressions by using intermediate results, and implementing function calls and recursion by saving activation records on a stack. 3) Stacks can be implemented using either a linked list or an array. The array implementation uses an array and a top pointer to track the top of the stack.

1. Chapter 3: Lists, Stacks, and
Queues - II
Text: Read Weiss, §3.6
1

2. The Stack ADT – Stack Model
•A stack (LIFO list) is a list with the restriction that
inserts and deletes can be performed in only one
position, namely the end of the list called the top.
•The two operations on a stack are push, pop (also top
to examine the item at the top). While pop on an empty
stack is generally considered an ADT error, running out
of space when performing a push is an implementation
error but not an ADT error.
2

3. 3
• Since a stack is a list, any list implementation will do.
• Singly Linked List implementation of a stack: push by inserting at
the front, pop by deleting the element at the front.
• Array implementation of stack: It is the more popular solution. It uses
the InsertToBack and DeleteFromBack from the Vector
implementation. Associated with each stack is Array and
TopOfStack which is set to -1 for an empty stack.
Implementation of Stacks
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, "%sn", Str), exit(1)
#define EmptyTOS ( -1 )
#define MinStackSize ( 5 )
typedef int ElementType;
struct StackRecord {
int Capacity;
int TopOfStack;
ElementType *Array;
};
typedef struct StackRecord *Stack;

4. Array Implementation of Stacks - I
4
int IsEmpty( Stack S ){
return S->TopOfStack == EmptyTOS;
}
int IsFull( Stack S ){
return S->TopOfStack == S->Capacity - 1;
}
Stack CreateStack( int MaxElements ){
Stack S;
if(MaxElements<MinStackSize) Error("Stack size is too small");
S = malloc( sizeof( struct StackRecord ) );
if(S == NULL) FatalError("Out of space!!!");
S->Array = malloc(sizeof(ElementType)*MaxElements);
if(S->Array == NULL) FatalError("Out of space!!!");
S->Capacity = MaxElements;
MakeEmpty(S);
return S;
}

5. 5
Array Implementation of Stacks - II
void MakeEmpty(Stack S){
S->TopOfStack = EmptyTOS;
}
void DisposeStack(Stack S){
if( S != NULL ){
free( S->Array );
free( S );
}
}
void Push(ElementType X, Stack S){
if( IsFull( S ) )
Error( "Full stack" );
else
S->Array[ ++S->TopOfStack ] = X;
}
void Pop( Stack S ){
if( IsEmpty( S ) )
Error( "Empty stack" );
else
S->TopOfStack--;
}
ElementType Top( Stack S ){ /* TopandPop is similar */
if( !IsEmpty( S ) )
return S->Array[ S->TopOfStack ];
Error( "Empty stack" );
return 0; /* Return value used to avoid warning */
}

6. 6
Stack Applications - Balancing Symbols
• Compilers check programs
for syntax errors, but
frequently a lack of one
symbol (such as a missing
brace or comment starter)
will cause the compiler to
spill out a hundred lines of
diagnostics. Thus, every
right brace, bracket, and
parenthesis must
correspond to their left
counterparts.
• Example: The sequence
[()] is legal, but [(]) is not.
stack Ø;
while (!eof(file)){
read(char);
if (isOpening(char))
push(char, stack);
else if (isClosing(char))
if (isEmpty(stack)
error();
else
cchar = topAndPop(stack);
if (!isMatching(char,cchar))
error();
}
if (!isEmpty(stack))
error();
It is clearly linear and actually makes
only one pass through the input. It is
thus on-line and quite fast.

7. Stack Applications – Postfix
Expressions
• Order of evaluation for arithmetic expressions
depending on the precedence and associativity of
operators has a huge impact on the result of the
evaluation.
• Example: 4.99 + 5.99 + 6.99 * 1.06 = produces either
19.05, or 18.39. Most simple four-function calculators
will give the first answer, but better calculators know
that multiplication has higher precedence than addition.
• A scientific calculator generally comes with
parentheses, so we can always get the right answer by
parenthesizing, but with a simple calculator we need to
remember intermediate results.
7

8. Postfix Notation
• (((a*b)+c)+(d*e)) fully parenthesized
• T1=a*b, T1=T1+c, T2=d*e, T1=T1+T2 by
using intermediate results
• a b * c + d e * + is the equivalent of using
intermediate results. This notation is
known as postfix or reverse Polish
notation.
• Notice that when an expression is given in
postfix notation, there is no need to know
any precedence rules.
8

9. Postfix Expression Evaluation
9
6 5 2 3 + 8 * + 3 + *
First four symbols are
placed on the stack.
+ 8 * + 3 + * 8 * + 3 + * * + 3 + * + 3 + *
3 + * + * *
This algorithm
depicted below
is clearly O(N)

10. Infix to Postfix Conversion
• We can use stacks to convert an
expression in standart form (otherwise
known as infix) into postfix.
• Example: operators = {+, *, (, )}, usual
precedence rules; a + b * c + (d * e + f) * g
Answer = a b c * + d e * f + g * +
10

11. Infix to Postfix - Algorithm
11
stack Ø;
while (! eos(expr)){
read(char);
if (isOperand(char))
output(char);
else if (char == “)”)
while ((!isEmpty(stack))&&((sc=topAndPop(stack))!= “(”))
output(sc);
else
while ( (!isEmpty(stack)) &&
(inStackPriority(top(stack))>=(outStackPriority(char))))
output(topAndPop(stack));
push(char, stack);
}
while (!isEmpty(stack))
output(topAndpop(stack));
inStackPriority(“(”)=very low outStackPriority(“(”)=very high
inStackPriority outStackPriority
** (RL) 4 5
*, / (LR) 3 3
+, - (LR) 2 2
( 1 6

12. Infix to Postfix – Example I
12
• * c + (d * e + f) * g
• + (d * e + f) * g
• (d * e + f) * g
• * e + f) * g
• a + b * c + (d * e + f) * g

13. Infix to Postfix – Example II
13
• + f) * g
• ) * g
• * g

14. Function Calls
• The algorithm to check balanced symbols suggests a way to
implement function calls.
• The problem here is that when a call is made to a new
function, all the variables local to the calling routine need to be
saved by the system.
• Furthermore, the current location in the routine must be saved
so that the new function knows where to go after it is done.
• “(“ and “)” are exactly like function call and function return.
• Every PL implementing recursion has that mechanism. The
information saved is called either an activation record or
stack frame. There is always the possibility that you will run
out of stack space by having too many simultaneously active
functions. On many systems there is no checking for overflow.
14

15. Function Calls and Recursion
• The routine print_list printing out a linked list, is perfectly legal
and actually correct. It properly handles the base case of an
empty list, and the recursion is fine. Unfortunately, if the list
contains 20,000 elements, there will be a stack of 20,000
activation records (and hence possibly a program crash).
• An example of an extremely bad use of recursion known as
tail recursion (recursive call at the last line). It can be
automatically eliminated by enclosing the body in a while loop
and replacing the recursive call with one assignment per
function argument.
15
void print_list( LIST L ) {
if( L != NULL ) {
print_element(L->element);
print_list( L->next );
}
}
void print_list( LIST L ){
while (1) {
if( L != NULL ){
print_element(L->element);
L = L->next;
}
}
}