UNIT-3 Stacks & Queues

Chapter 1: Stacks
Introduction to Stacks, Array Representation of Stacks, Operations on Stack,
Linked Representation of Stacks, Applications of Stacks, Evaluation of a Postfix
Expression, Conversion of infix expression into a postfix expression.

Introduction to Stacks
A Stack is a linear data structure that follows the LIFO (Last-In-First-Out) principle. Stack
has one end, whereas the Queue has two ends (front and rear).
It contains only one pointer top pointer pointing to the topmost element of the stack.
Whenever an element is added in the stack, it is added on the top of the stack, and the element
can be deleted only from the stack.
In other words, a stack can be defined as a container in which insertion and deletion can be
done from the one end known as the top of the stack.

Working of Stack
Stack works on the LIFO pattern. As we can observe in the below figure there are five memory
blocks in the stack; therefore, the size of the stack is 5.
Suppose we want to store the elements in a stack and let's assume that stack is empty. We have
taken the stack of size 5 as shown below in which we are pushing the elements one by one until
the stack becomes full.
UNIT-3 Stacks & Queues

Operations on Stack
 push(): When we insert an element in a stack then the operation is known as a push. If
the stack is full then the overflow condition occurs.
 pop(): When we delete an element from the stack, the operation is known as a pop. If the
stack is empty means that no element exists in the stack, this state is known as an
underflow state.
 isEmpty(): It determines whether the stack is empty or not.
 isFull(): It determines whether the stack is full or not.'
 peek(): It returns the element at the given position.
 count(): It returns the total number of elements available in a stack.
 change(): It changes the element at the given position.
 display(): It prints all the elements available in the stack.

PUSH operation
The steps involved in the PUSH operation is given below:
o Before inserting an element in a stack, we check whether the stack is full.
o If we try to insert the element in a stack, and the stack is full, then
the overflow condition occurs.
o When we initialize a stack, we set the value of top as -1 to check that the stack is empty.
o When the new element is pushed in a stack, first, the value of the top gets incremented,
i.e., top=top+1, and the element will be placed at the new position of the top.
o The elements will be inserted until we reach the max size of the stack.
UNIT-3 Stacks & Queues

POP operation
The steps involved in the POP operation is given below:
o Before deleting the element from the stack, we check whether the stack is empty.
o If we try to delete the element from the empty stack, then the underflow condition
occurs.
o If the stack is not empty, we first access the element which is pointed by the top
o Once the pop operation is performed, the top is decremented by 1, i.e., top=top-1.
UNIT-3 Stacks & Queues

Applications of Stack
o String reversal: Stack is also used for reversing a string.
o UNDO/REDO: It can also be used for performing UNDO/REDO operations. For
example, we have an editor in which we write 'a', then 'b', and then 'c'; therefore, the
text written in an editor is abc. So, there are three states, a, ab, and abc, which are stored
in a stack. There would be two stacks in which one stack shows UNDO state, and the
other shows REDO state.
If we want to perform UNDO operation, and want to achieve 'ab' state, then we
implement pop operation.
o Recursion: The recursion means that the function is calling itself again. To maintain
the previous states, the compiler creates a system stack in which all the previous records
of the function are maintained.
o DFS(Depth First Search): This search is implemented on a Graph, and Graph uses the
stack data structure.
o Backtracking: Suppose we have to create a path to solve a maze problem. If we are
moving in a particular path, and we realize that we come on the wrong way. In order to
come at the beginning of the path to create a new path, we have to use the stack data
structure.
o Expression conversion: Stack can also be used for expression conversion. This is one
of the most important applications of stack. The list of the expression conversion is
given below:
 Infix to prefix

 Infix to postfix

 Prefix to infix

 Prefix to postfix

 Postfix to infix

o Memory management: The stack manages the memory. The memory is assigned in
the contiguous memory blocks. The memory is known as stack memory as all the
variables are assigned in a function call stack memory. The memory size assigned to
the program is known to the compiler. When the function is created, all its variables are
assigned in the stack memory. When the function completed its execution, all the
variables assigned in the stack are released.
UNIT-3 Stacks & Queues

Array Representation of a Stack

An array is used to store an ordered list of elements. Using an array for representation of stack
is one of the easy techniques to manage the data. But there is a major difference between an
array and a stack.
 Size of an array is fixed.
 While, in a stack, there is no fixed size since the size of stack changed with the number
of elements inserted or deleted to and from it.
Despite the difference, an array can be used to represent a stack by taking an array of maximum
size; big enough to manage a stack.

For Example:
We are given a stack of elements: 12 , 08 , 21 , 33 , 18 , 40.

Step 1:
 Push (40).
 Top = 40
UNIT-3 Stacks & Queues

 Element is inserted at a[5].

Step 2:
 Push (18).
 Top = 18
 Element is inserted at a[4].

Step 3:
 Push (33).
 Top = 33
 Element is inserted at a[3].

Step 4:
 Push (21).
 Top = 21
 Element is inserted at a[2].
UNIT-3 Stacks & Queues

Step 5:
 Push (08).
 Top = 08
 Element is inserted at a[1].

Step 6:
 Push (12).
 Top = 12
 Element is inserted at a[0].

Step 7:
 Top = -1.
 End of array.
UNIT-3 Stacks & Queues

Implementation of Stack using Array

#include<stdio.h>
#include<conio.h>

#define SIZE 10

void push(int);
void pop();
void display();

int stack[SIZE], top = -1;

void main()
{
int value, choice;
clrscr();
while(1){
printf("\n\n***** MENU *****\n");
printf("1. Push\n2. Pop\n3. Display\n4. Exit");
printf("\nEnter your choice: ");
scanf("%d",&choice);
switch(choice){
case 1: printf("Enter the value to be insert: ");
scanf("%d",&value);
push(value);
break;
case 2: pop();
UNIT-3 Stacks & Queues

break;
case 3: display();
break;
case 4: exit(0);
default: printf("\nWrong selection!!! Try again!!!");
}
}
}
void push(int value){
if(top == SIZE-1)
printf("\nStack is Full!!! Insertion is not possible!!!");
else{
top++;
stack[top] = value;
printf("\nInsertion success!!!");
}
}
void pop(){
if(top == -1)
printf("\nStack is Empty!!! Deletion is not possible!!!");
else{
printf("\nDeleted : %d", stack[top]);
top--;
}
}
void display(){
if(top == -1)
printf("\nStack is Empty!!!");
else{
int i;
printf("\nStack elements are:\n");
for(i=top; i>=0; i--)
printf("%d\n",stack[i]);
}
UNIT-3 Stacks & Queues

Output:
***** MENU *****
1. Push
2. Pop
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 40
Insertion success!!!

***** MENU *****

1. Push
2. Pop
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 50
Insertion success!!!

***** MENU *****

1. Push
2. Pop
3. Display
4. Exit
Enter your choice: 3
Stack elements are:
50
40

***** MENU *****

1. Push
UNIT-3 Stacks & Queues

2. Pop
3. Display
4. Exit
Enter your choice: 4

Linked Representation of a Stack

Evaluation of a Postfix Expression
Conversion of Infix Expression into a Postfix Expression