DEFINITION OF STACK

A stack is a linear data structure in which insertions and deletions are

allowed only at the end, called the top of the stack.

/HEAT.

Stack of books Stack of coins

Objects placed inside the glass jars

 STACK AS AN ADT

When we define a stack as an ADT (or Abstract Data Type), then we are
only interested in knowing the stack operations from the user point of
view.

Means we are not interested in knowing the implementation details at this

moment. We are only interested in knowing what type ot operations we
can
ertorm on stack.

PRIMARY STACK OPERATIONS

push (data): Inserts data onto stack.

DATA
 PR1MAY STACK OPERATIONS

pop(): Deletes the last inserted element from the stack.

DATA

SECONDARY STACK OPERATIONS

top(): returns the last inserted element without removing

it.
 SECONDARY STACK OPERATIONS

isEmptyO): returns TRUE if the stack is empty, else returns

FALSE.

isFull(): returns TRUE if the stack is full, else returns FALSE.

yr
List of commands

□
~

push(1)

□ push(2)

□ push(3)

□ pop()

□ isFull)
 •
isFull() = FALS E
 Array implementation

A stack is a linear data structure in which insertions and deletions are

allowed only at the end, called the top of the stack.

As a stack is a linear data structure, we can implement it using an

array or a

ARRAY IMPLEMENTATION

We know that stack_arr[] is an array and insertion and deletion

operations can be performed at any place but we want the
stack_arr[] to behave like a stack.
Hence, the insertions and deletions must be performed at the end.

For this, we will keep a variable top which will keep track of the
last inserted element or the topmost element in an array.

EMPTY STACK

To indicate that the stack is empty, we will put -l in the variable

top.
 PUSH(D)

.
For the push operation:
# top is incremented by I.
# New element is pushed at the position top.

PUSH(1)

For the push operation:

# top is incremented by l.
# New element is pushed at the position top.
 SERIES OF PUSH AND POP OPERATIONS

push(2)
push(3)
push(5)
push(10)
push(11)

SERIES OF PUSH AND POP OPERATIONS

1 2 3 5 10 11

push(2)
push(3)
push(S)
push(10)
push(11)
 SERIES OF PUSH AND POP OPERATIONS

push(2)
push(3) Not possible. There is not
push(5) enough space in the stack.
push(10) This state is called the
overflow state and the
push(11) new element can't be
push(12) pushed.

SERIES OF PUSH AND POP OPERATIONS

10 11

For the pop operation:

± The element at the position of top is deleted.
# top is decremented by I.
 SERIES OF PUSH AND POP OPERATIONS

For the pop operation:

% The element at the position of top is deleted.
k top is decremented by l.

SERIES OF PUSH AND POP OPERATIONS

For the pop operation:

% The element at the position of top is deleted.
# top is decremented by I.
 SERIES OF PUSH AND POP OPERATIONS

] } u r

push(2)
push(3)
push(5)
push(10)
push(11)
pop
pop

Question 1 IF the sequence of operations - push (1), push (2), pop, push (1),
push (2), pop, pop, pop, push (2), pop are performed on a stack,
the sequence ot popped out values

(A) 2, 2,1,1, 2 (B) 2, 2, 1,2, 2

(C) 2,1,02, 2,1 (D) 2,1, 2, 2, 2
. ISRO CS 2015

Question 2 Consider the following operations performed on a stack of size 5:

Push(a); Pop(); Push(b); Push(c); Pop(); Push(d); Pop(); Pop(); Push(e)
Which of the following statements is correct?

(A) Underflow occurs (B) Stack operations are performed smoothly

(C) Overflow occurs (D) None of the mentioned
UGC NET CS 92016
July - II
Question 1 Which of the following permutation can be obtained in the same
order u'ng a stack assuming that input is the sequence 5, 6, 7, 8, 9 in that
order?

(A) 7, 8, 9, 5, ( B) 5, 9, 6, 7,8
6 ( D) 9, 8, 7, 5, 6 ISRO CS 92017
(C) 7, 8, 9, 6, 5

Question 2.
Stack A has the entries a, b, c (with a on top). Stack B is
empty. An entry popped out of stack A can be printed immediately or
pushed to stack B. An entry popped out of the stack B can be only be
printed. In this
arrangement, which of the following permutations of a, b, c are not possible?

(A) b, a, c (B) b, c, a
ISRO CS 2018
(C) c, a, b (D) a, b, c

Why linked list representation?

Why should we prefer the beginning of the linked list
as the top of the stack?
Basic idea on how to write a program for linked list
implementation of stack.
 \WHY LINKED LIST REPRESENTATION?

Simple Answer • Use linked list when the size of the stack is not
known in advance.

Size is known in
stack 1
advance.

stack No limitation
on the number
of nodes we
can" create:)

TOP OF THE STACK

We will select the beginning of the linked list as the top of the stack.

stack

Let say, we want to insert element 50 onto stack.

This new element will be pushed in front of the linked list.
 TOP OF THE STACK

We will select the beginning of the linked list as the top of the stack.

stack

For pop operation, everytime the first node of the linked list will be

deleted. This automatically holds because the top pointer is pointing to the

first node
of the linked list.
Let's try to delete the first node of the linked list.

BUT WHY WE PREFER ADDING AND REMOVING THE FIRST

NODE OF THE LINKED LIST?

Time complexity of adding a node at the end: 0(1)

stack

•
head

tcD
Time complexity of adding a node at the end: 0(1)

stack

head

Time complexity of adding a node at the end:

0(1)

stack

head

Time complexity of adding a node at the end: 0(1)

Time complexity of removing the last node: 0(n)
w

stack 50

head

Deleting the last node of the singly

linked list requires traversal
 TIME COMPLEXITY COMPARISON

Inserting a new node Deleting a node

0(1) 0(1)

0(1) At the end O(n)

The code of the function must be similar to the code

of inserting the node at the beginning of the singly linked list.

The code of pop() function must be similar to the code of deleting

the first node of the singly linked list.

Stack overflow occurs when there is no space left to

dynamically allocate the memory. In that case, malloc() function
will return NULL.

tack
.
underflow occurs when top is equal to NU LL.

Stack implementation by using arrays

#include<stdio.h
>
#define size 10
int stack_array[size];
int top=-1;
void push(int ele);
int pop();
void
stack_print();
void
stack_top0;
void
is_empty();
void is_full0;
void stack_freespace();
int main()
{
while(l)
{
int ch,ele,x;
printf("\nl .push\n2.pop\n3 .top\n4.is_empty\n5
.is_full\n6.freespace\n7 .print stack elements");
printf("\n enter your choice");
scanf("%d" &ch);
switch(ch)
{
case 1 :printf("enter the element");
scanf("¾d" ,&ele);
push(ele);
break;
case
2:x=pop();
printf("\n the deleted element is:%d" ,x);
break;
case 3: stack_top();
break;
case 4:is_empty();
break;
case 5
:is_full();
 break;
case 6: stack_free space();
break;
case 7: stack_print();
break;

}
return 0;
}
void stack_freespace()
{
float per;
per=((size-I )-top)* 100/size;
printf("stack free percentage is %f'',per);
}
void is_full()
{
if(top==size-1)
printf("stack is overflow");
else
printf("stack is not full");
}
void is_empty()
{
if(top==- I)
{
printf("stack is underflow");
}
else
{
printf("stack is not empty");
}
}
void stack_top()
{
printf("the top of the stack element is %d" ,stack_array[top]);
}
void stack_print()
{
inti;
if(top==- I)
{
printf("stack is empty");
}
else
{
printf("the stack elements are:");
for(i=top;i>=O;i--)
{
printfU"%d\t",stack_array[i]);
}
}
}
void push(int ele)
{
if(size- I ==top)
{
printf("\n stack is overflow");
}
else
{
top=top+ 1;
stack_array[top]=ele;
}
}
int pop()
{
int value;
if(top==- I)
{
printf(" stack underflow");
}
else
{
value=stack_array[top];
top=top-1;
}
return value;
}

Stack implementation by using linked list

#include<stdio.h>

#include<stdlib.h>

struct node

int data;

struct node *link;

} *stack_head;

typedef struct node node;

void print();

void push(int ele);

int main()

int ch,ele;

while(l)

printf("\nl .push\n2.pop\n3 .top\n");

printf("\n enter your choice");

scanf("¾d" ,&ch);

switch(ch)

case 1 :printf("\n enter the element");

scanf("¾d" ,&ele);

push(ele);

break;

case 2:print();

break;

case 3 :pop();

break;

return O;

}
void print()

if(stack_head==NULL)

printf("\n stack is empty");

else

node temp=stack_head;

printf("stack elements from bottom to top is:");

while(temp!=NULL)

printfU"%d\t",temp->data);

temp=temp->link;

}
void push(int ele)

if(stack_head==NULL)

stack_head=(node*)malloc(sizeof(node));

if(stack_head== NULL)

printf("stack over flow");

stack_head->data=ele;

stack_head->link=NULL;

else

node *top=(node*)malloc(sizeof(node));

if(top==NULL)

printf("stack overflow");

exit(O);

top->data=ele;

top->link=stack_head;

stack_head=top;

}}
void pop()

if(stack_head==NULL)

printf("stack under flow");

exit(O);

else

node temp=stack_head;

printf("\n the deleted element is %d",temp->data);

temp=temp->link;

stack_head=temp;

}
 Stack applications

1. Evolution of arithmetic expression

2. Conversion from infix to postfix
3. Evolution of postfix expression
4. Recursion
5. Functional calls
6. Back button implementation
7. Undo operation in MS-Word
Comparison;
]
Addition
] f•
first 10 + 4 5 = 70
A
fY uiipMICC1 o
4 ] 4
n £.11rSl, 10 + 4 5 =

PRECEDENCE OF OPERATORS

Priorities of the operators are predefined.

We will consider the five different operators: +, -, , /,

Priority

(Exponentiation) 1 (Highest)
-.-··
(Multiplication) and /
(Division]

+ (Addition) and - (Subtraction) 3 (lowest)

 Operators Priority
n (Exponentiatian) 1 (Highest)

• (Multiplication) and J (Division) 2

4 (Addition) and (Subtraction) 3 (Lowest)

A 1 £
I1!1!l 10 + 4 5 = 70
hrsl

Maltiolication
10 +4{5=

Find the result of the following infix expression:

3 +5 7 - 42
-ii

Operators Priority

(Exponentiation 1 (Highest)
)

(Multiplication) and / (Division)

+ (Addition) and - (Subtraction) 3 (Lowest)

Example-3

3 +56-7

254 + 10 - 9

365 k
52 k 7 + 10 I 10
3 + 5 * (7 4) AN
2

8 k
(5 i\
4 + 2) - 6 A
2 I (9 k
3)
Two ways to represent an expression:

Infix Notation
 WHAT IS AN INFIX EXPRESSION?

Infix Notation: A + B
The operators are written in between there operands.

sample
L I - ' - • -

A+B/C
.
The expression literally
means
first add A and B, then divide the result by C

MOE INFORMATION

nfix expression requires extra information to make the order ot

evaluation of operators clear.
lt requires the information about precedence and associativity of operators.

Earnele

A+B/C

The usual rule says that the division must be performed before
addition and subtraction.
 A +B/C'D-E/(F+G)

A AB/CD-E/(F+G)

A+B/CD-E/(F+G),

The above expression requires multiple scans and every time we have to
reach a different place in an expression for evaluation,
 A+B/C'DE/(F+G)
lr

Scan #]. Found an expression between parentheses

(F+G) has the highest priority.

Scan #2. B/C has the second highest priority.

Scan #3. The result of B/C and D must be multiplied next.

INFIX NOTATION REQUIRES MULTIPLE SCANS AND

1IS, THEREFORE, INEFFICIENT (IN TERMS OF TIME
CONSUMPTION)

Two ways to represent an expression:

Post f ix Notation
..
 \WHAT IS A POSTFIX NOTAT10N?

Notation: AB +

The operators are written after their operands

ABC/ +
l

The order of evaluation ot operators is left to right with no brackets in the

expression to change the order

ln the example, division comes before addition, and therefore, the

division
must be performed before addition

Infix Expression

Step-1

A+ B / C * D - E / (FG+)
Step-2

A + BC/ D - E / (FG+)
Step-3

A +[BC/ D - E / (FG+)

• I
Operand 2

A + BC/D - E / (FG+)
Step-4

Step-5

ABC/D*+ - EFG+/
Step-6

Postfix Expression

ABC/D+EFG+/•
.
• I
I
.

. i
•
. . i-i
A+B/CD-E/(F+G) ABC/D+EFG+/•

POSTFIX NOTATION DOESN'T REQUIRE MULTIPLE

SCANS (A SINGLE SCAN IS REQUIRED) AND IS,
THEREFORE, EFFICIENT (IN TERMS OF TIME
CONSUMPTION)

ALGORITHM
h
can the syntals cf the expression from left to right and for each symbul,
do the following:
a. If symbol is an operand
Print that symbol onto the screen
b. I+ symbol is a left parenthesis
a Push it an the stack,
c. If symbol is a right parenthesis
m Popi all the oneratnr Frum the stark uintn the first left
parenthesis and print them on the screen_.
a Discard the left and right
parentheses, d. If symbol is an operator
TF the prwcdrnc n" the operators in the stack arr greater than tr
equal to the current uperalur, then
Pop the operators out of the stack and print them onto
the screen, and push the current nprratar onto the stack,

Push the current operator unto the stack.

 7+53/51+(3-2)
l

Output: 7

output: 7535
 7+53/51+(3-2)

Output:

7+53/51+(3-2)

Output: 75351/+32-¢ %

Example2:
 Evolution of postfix Expression
Begin

for each character ch in the postfix expression, do

if ch is an operator 0 , then

a := pop first element from stack

b := pop second element from the stack

res:= b 0 a

push res into the stack

else if ch is an operand, then

add ch into the stack

done

return element of stack top

End

Example:
Let the given expression be "2 31+ 9-". We scan all elements one by one.
1) Scan '2', it's a number, so push it to stack. Stack contains '2'
2) Scan '3', again a number, push it to stack, stack now contains '2 3'
(from bottom to top)
3) Scan '1, again a number, push it to stack, stack now contains '2 31
4) Scan '*', it's an operator, pop two operands from stack, apply the operator
on operands, we get 3*1 which results in 3. We push the result '3' to stack.
The stack now becomes '2 3'.
5) Scan '+', it's an operator, pop two operands from stack, apply the +
operator on operands, we get 3 + 2 which results in 5. We push the result '5'
to stack. The stack now becomes '5'.
6) Scan '9', it's a number, we push it to the stack. The stack now becomes '5
9'.
7) Scan '-', it's an operator, pop two operands from stack, apply the --
operator on operands, we get 5 - 9 which results in -4. We push the result '-4'
to the stack. The stack now becomes '-4'.
8) There are no more elements to scan, we return the top element from
the stack (which is the only element left in a stack).