CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

UNIT II STACK AND QUEUES

Stack ADT – Operations – Applications – Evaluating arithmetic expressions- Conversion of
Infix to postfix expression – Queue ADT – Operations – Circular Queue – Priority Queue –
deQueue –applications of queues.

STACK
Stack is a Linear Data Structure that follows Last In First Out(LIFO) principle. Insertion and deletion can
be done at only one end of the stack called TOP of the stack.Example: - Pile of coins, stack of trays
STACK ADT:

STACK MODEL

TOP pointer

It will always point to the last element inserted in the stack.For empty stack, top will be pointing to -1.
(TOP = -1) Operations on Stack (Stack ADT)
Two fundamental operations performed on the stack are PUSH and POP.
(a) PUSH - It is the process of inserting a new element at the Top of the stack.
For every push operation:
1. Check for Full stack ( overflow ).
2. Increment Top by 1. (Top = Top + 1)
3. Insert the element X in the Top of the stack.
(b) POP - It is the process of deleting the Top element of the stack.
For every pop operation:
1. Check for Empty stack ( underflow ).
2. Delete (pop) the Top element X from the stack
3. Decrement the Top by 1. (Top = Top - 1 )
Exceptional Conditions of stack
1. Stack Overflow
An Attempt to insert an element X when the stack is Full, is said to be stack overflow.
For every Push operation, we need to check this condition.
2. Stack Underflow:
An Attempt to delete an element when the stack is empty, is said to be stackunderflow.
For every Pop operation, we need to check this condition.
Implementation of Stack
Stack can be implemented in 2 ways.
1. Static Implementation (Array implementation of Stack)
2. Dynamic Implementation (Linked List Implementation of Stack)
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Array Implementation of Stack

Each stack is associated with a Top pointer.For Empty stack, Top = -1.
Stack is declared with its maximum size.
Array Declaration of Stack:
#define ArraySize 5
int S [ Array Size]; or int S [ 5];
Stack Empty Operation:
Initially Stack is Empty.
With Empty stack Top pointer points to
It is necessary to check for Empty Stack before deleting (pop) an element from the stack.

Routine to check whether stack is empty

int IsEmpty (Stack S)

{
if (Top = = - 1)
return (1);
}

(i) Stack Full Operation:

As we keep inserting the elements, the Stack gets filled with the elements.
Hence it is necessary to check whether the stack is full or not before inserting a newelement into the stack.

Routine to check whether a stack is full

int IsFull (Stack S)

{ if (Top = = Arraysize 1)

return (1);

(ii) Push Operation

It is the process of inserting a new element at the Top of the stack.

It takes two parameters. Push (X, S) the element X to be inserted at the Top of the Stack S.
Before inserting an Element into the stack, check for Full Stack.If the Stack is already Full, Insertion is not
possible.
Otherwise, Increment the Top pointer by 1 and then insert the element X at the Top of theStack.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Routine to push an element into the stack

void Push (int X, Stack S)
{
if (Top = = Arraysize - 1)
is full!!Insertion is not
else
{ Top = Top + 1;
S [ Top] =X;
}
}

(iv) Pop Operation

It is the process of deleting the Top element of the stack.
It takes only one parameter. Pop(X). The element X to be deleted from the Top of theStack.
Before deleting the Top element of the stack, check for Empty Stack.If the Stack is Empty, deletion is not
possible.
Otherwise, delete the Top element from the Stack and then decrement the Top pointer by1.
Routine to Pop the Top element of the stack

void Pop (Stack S)

{
if (Top = = - 1)
Error ( stack!
Deletion not
else
{
X = S [ Top];
Top = Top-1;
}
}

(v) Return Top Element

Pop routine deletes the Top element in the stack.
If the user needs to know the last element inserted into the stack, then the user can returnthe Top element of
the stack.
To do this, first check for Empty Stack.
If the stack is empty, then there is no element in the stack.
Otherwise, return the element which is pointed by the Top pointer in the Stack.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Routine to return top Element of the stack

int TopElement(Stack S)
{
if(Top==-1)
{

return 0;
}
else
return S[Top];
}

Linked list implementation of Stack

Stack elements are implemented using SLL (Singly Linked List) concept.Dynamically, memory is allocated
to each element of the stack as a node.
Type Declarations for Stack using SLL
struct node;
typedef struct node *stack;
typedef struct node *position;
stack S;
struct node
{
intdata;
position next;
};
int IsEmpty(Stack S);
void Push(int x, Stack S);
void Pop(Stack S);
int TopElement(Stack S);

Stack Empty Operation:

Initially Stack is Empty.
With Linked List implementation, Empty stack is represented as S -> next = NULL.
It is necessary to check for Empty Stack before deleting ( pop) an element from the stack.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Routine to check whether the stack is empty S

int IsEmpty( Stack S) HEADER NULL

{
if ( S -> next = = NULL)
EMPTY STACK
return ( 1 );
}

(i) Push Operation

It is the process of inserting a new element at the Top of the stack.
With Linked List implementation, a new element is always inserted at the Front of theList.(i.e.) S -> next.
It takes two parameters. Push(X, S) the element X to be inserted at the Top of the StackS.Allocate the
memory for the newnode to be inserted.
Insert the element in the data field of the newnode.
Update the next field of the newnode with the address of the next node which is storedin the S -> next.
S

Header

30 20 10 NULL

40

newnode
Before Insertion
Push routine /*Inserts element at front of the list

void push(int X, Stack S)

{
Position newnode, Top;
newnode = malloc (sizeof( struct node ) );
newnode -> data = X;
newnode -> next = S -> next;
S -> next = newnode;
Top = newnode;
}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Header

40 30 20 10 NULL

After Insertion
TOP
(ii) Pop Operation
It is the process of deleting the Top element of the stack.
With Linked List implementations, the element at the Front of the List(i.e.) S -> next is always deleted.
It takes only one parameter. Pop(X).The element X to be deleted from the Front of theList.
Before deleting the front element in the list, check for Empty Stack.If the Stack is Empty, deletion is not
possible.
Otherwise, make the front element in the list as Update the next field of header.
Using free ( ) function, Deallocate the memory allocated for temp node.

Header

2 1 N
0 PANIMALA 0 U
40 30 L
L
R
S
TOP
Before Deletion
Pop routine /*Deletes the element at front of list
void Pop( Stack S )
{
Position temp, Top;
Top = S -> next;
if( S -> next = = NULL)
stack! Pop
else
{
Temp = S -> next;
S -> next = temp -> next;
free(temp);
Top = S -> next;
}}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Header

40 30 20 10 NULL

HEADER

30 20 10 NULL

After Deletion
(iii) Return Top Element
Pop routine deletes the Front element in the List.
If the user needs to know the last element inserted into the stack, then the user canreturn the Top element of
the stack.
To do this, first check for Empty Stack.
If the stack is empty, then there is no element in the stack.
Otherwise, return the element present in the S -> next -> data in the List.
Routine to Return Top Element
int TopElement(Stack S)

if(S->next==NULL)

is

return 0;

else

return S->next->data;

}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Header

40 30 20 10 NULL

TOP
Applications of Stack

The following are some of the applications of stack:

1. Evaluating the arithmetic expressions
Conversion of Infix to Postfix Expression
Evaluating the Postfix Expression
2. Balancing the Symbols
3. Function Call
4. Tower of Hanoi
5. 8 Queen Problem
Evaluating the Arithmetic Expression
There are 3 types of Expressions
• Infix Expression
• Postfix Expression
• Prefix Expression
INFIX:
The arithmetic operator appears between the two operands to which it is beingapplied.

POSTFIX:
The arithmetic operator appears directly after the two operands to which it applies.Also
called reverse polish notation.

PREFIX:
The arithmetic operator is placed before the two operands to which it applies. Alsocalled
polish notation.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Evaluating Arithmetic Expressions

1. Convert the given infix expression to Postfix expression
2. Evaluate the postfix expression using stack.

Algorithm to convert Infix Expression to Postfix Expression:

Read the infix expression one character at a time until it encounters the delimiter
Step 1: If the character is an operand, place it on the output.
Step 2: If the character is an operator, push it onto the stack. If the stack operator has a higher orequal
priority than input operator then pop that operator from the stack and place it onto the output.
Step 3: If the character is left parenthesis, push it onto the stack
Step 4: If the character is a right parenthesis, pop all the operators from the stack till it encountersleft
parenthesis, discard both the parenthesis in the output.
E.g. Consider the following Infix expression: - A*B+(C-D/E)#
Read char Stack Output
A
* * A
+
`B AB
*
+ + AB*
(
( AB*
+
(
C AB*C
+
-
- ( AB*C
+
-
D ( AB*CD
+
/
-
/ AB*CD
(
+
/
-
E AB*CDE
(
+
/
-
) AB*CDE/-
(
+
# AB*CDE/-+
Output: Postfix expression:- AB*CDE/-+
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Evaluating the Postfix Expression

Algorithm to evaluate the obtained Postfix Expression
Read the postfix expression one character at a time until it encounters the delimiter
Step 1: If the character is an operand, push its associated value onto the stack.
Step 2: If the character is an operator, POP two values from the stack, apply the operator tothem and push
the result onto the stack.
E.g consider the obtained Postfix expression:- AB*CDE/-+

Operand Value
A 2
B 3
C 4
D 4
E 2

Char Read Stack

A 2
B 3
2
* 6
C 4
6
D 4
4
6
E 2
4
4
6
/ 2
4
6
- 2
6
+ 8

OUTPUT = 8
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024
Coding for Implementing Infix to Postfix Conversion
#define SIZE 50 /* Size of Stack */
#include <ctype.h>
char s[SIZE];
int top=-1; /* Global declarations */
void push(char elem)
{
s[++top]=elem;
}
char pop()
{
return(s[top--]);
}
int pr(char elem)
{ /* Function for precedence */
switch(elem)
{
case '#': return 0; case '(': return 1; case '+':
case '-': return 2;case '*':
case '/': return 3;
}
return 0;
}
Void main()
{ /* Main Program */
char infx[50],pofx[50],ch,elem;
int i=0,k=0;
printf("\nRead the Infix Expression ? ");
scanf("%s",infx);
push('#');
while( (ch=infx[i++]) != '\0')
{
if( ch == '(')
push(ch);
else if(isalnum(ch))
pofx[k++]=ch;
else if( ch == ')')
{
while( s[top] != '(')
pofx[k++]=pop();
elem=pop(); /* Remove */
}
else
{ /* Operator */
while( pr(s[top]) >= pr(ch) )
pofx[k++]=pop();
push(ch);
}
}

while( s[top] != '#') /* Pop from stacktill empty

pofx[k++]=pop();
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024
pofx[k]='\0'; /* Make pofx as validstring */
printf("\n\nGiven Infix Expn: %s PostfixExpn: %s\n",infx,pofx);
}
OUTPUT
Read the Infix Expression ?
(a+b)-(c-d)
Given Infix Expn: (a+b)*(c-d)Postfix Expn: ab+cd-*

QUEUES:
Queue is a Linear Data Structure that follows First in First out (FIFO) principle.
Insertion of element is done at one end of the Queue called Rear end of the Queue.
Deletion of element is done at other end of the Queue “Front” the Queue.
Example: - Waiting line in the ticket counter.

Front End Rear End

QUEUE Q
Deletion Insertion

Front Pointer - It always points to the first element inserted in the Queue.
Rear Pointer - It always points to the last element inserted in the Queue.
For Empty Queue:-
Front (F) = - 1
Rear (R) = - 1

Operations on Queue
Fundamental operations performed on the queue are
1. EnQueue
2. DeQueue

(i) EnQueue operation: -

It is the process of inserting a new element at the rear end of the Queue.
For every EnQueue operation
Check for Full Queue
If the Queue is full, Insertion is not possible.
Otherwise, increment the rear end by 1 and then insert the element in the rear endof the Queue.
(ii) DeQueue Operation: -
It is the process of deleting the element from the front end of the queue.
For every DeQueue operation
Check for Empty queue
If the Queue is Empty, Deletion is not possible.
Otherwise, delete the first element inserted into the queue and then increment thefront by 1.
Exceptional Conditions of Queue
Queue Overflow
Queue Underflow
(i) Queue Overflow:
An Attempt to insert an element X at the Rear end of the Queue when theQueue is full is said to be Queue
overflow.
For every Enqueue operation, we need to check this condition.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024
(ii) Queue Underflow:
An Attempt to delete an element from the Front end of the Queue when theQueue is empty is said to be
Queue underflow.
For every DeQueue operation, we need to check this condition.

Implementation of Queue
Queue can be implemented in two ways.
1. Implementation using Array (Static Queue)
2. Implementation using Linked List (Dynamic Queue)
Array Declaration of Queue:
#define ArraySize 5
int Q [ ArraySize]; Or int Q [ 5 ];

Initial Configuration of Queue:

(i) Queue Empty Operation:

Initially Queue is Empty.
With Empty Queue, Front ( F ) and Rear ( R ) points to -1.
It is necessary to check for Empty Queue before deleting (DeQueue) an element from theQueue (Q).
Routine to check for Empty Queue
int IsEmpty ( Queue Q )
{
if( ( Front = = - 1) && ( Rear = = - 1 ) )return ( 1 );
}

int IsEmpty ( Queue Q )

if( ( Front = = - 1) && ( Rear = = - 1 ) )

return ( 1 );

}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024
Queue Full Operation
As we keep inserting the new elements at the Rear end of the Queue, the Queue becomesfull.
When the Queue is Full, Rear reaches its maximum Arraysize.
For every Enqueue Operation, we need to check for full Queue condition.
Routine to check for Full Queue
int IsFull( Queue Q )

if ( Rear = = ArraySize - 1 )

return ( 1 );

Enqueue Operation

It is the process of inserting a new element at the Rear end of the Queue.
It takes two parameters, Enqueue(X, Q). The elements X to be inserted at the Rear end ofthe Queue Q.
Before inserting a new Element into the Queue, check for Full Queue.If the Queue is already Full, Insertion
is not possible.
Otherwise, Increment the Rear pointer by 1 and then insert the element X at the Rear endof the Queue.
If the Queue is Empty, Increment both Front and Rear pointer by 1 and then insert theelement X at the Rear
end of the Queue.
Routine to Insert an Element in a Queue
void EnQueue (int X , Queue Q)
{
if ( Rear = = Arraysize - 1)
print (" Full Queue !!!!. Insertion notpossible");
else if (Rear = = - 1)
{
Front = Front + 1;Rear = Rear + 1; Q [Rear] = X;
}
else
{
Rear = Rear + 1;Q [Rear] = X;
}
}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

(ii) DeQueue Operation

It is the process of deleting a element from the Front end of the Queue.
It takes one parameter, DeQueue (Q). Always front element in the Queue will be deleted.Before deleting an
Element from the Queue, check for Empty Queue.
If the Queue is empty, deletion is not possible.
If the Queue has only one element, then delete the element and represent the empty queue by updating Front
= - 1 and Rear = - 1.
If the Queue has many Elements, then delete the element in the Front and move the Front pointer to next
element in the queue by incrementing Front pointer by 1.

ROUTINE FOR DEQUEUE

void DeQueue ( Queue Q )

{
if ( Front = = - 1)
print (" Empty Queue !. Deletion not possible " );else if( Front = = Rear )
{
X = Q [ Front ];Front = - 1; Rear = - 1;
}
else
{
X = Q [ Front ]; Front = Front + 1 ;

}
}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024
Linked List Implementation of Queue
Queue is implemented using SLL (Singly Linked List ) node.
Enqueue operation is performed at the end of the Linked list and DeQueueoperation is performed at the
front of the Linked list.
With Linked List implementation, for Empty queue
Front = NULL & Rear = NULL
Linked List representation of Queue with 4 elements

Header

10 20 30 40 NULL

Front Rear

Declaration for Linked List Implementation of Queue ADT

struct node;
typedef struct node * Queue;
typedef struct node * position;
int IsEmpty (Queue Q);
Queue CreateQueue (void);
void MakeEmpty (Queue Q);
void Enqueue (int X, Queue Q);
void Dequeue (Queue Q);
struct node
{
int data ;
position next;
}* Front = NULL, *Rear = NULL;
(i) Queue Empty Operation:
Initially Queue is Empty.
With Linked List implementation, Empty Queue is represented as S -> next = NULL.
It is necessary to check for Empty Queue before deleting the front element in the Queue.
ROUTINE TO CHECK WHETHER THE QUEUE IS EMPTY
int IsEmpty (Queue Q
{
If (Q->next == NULL) Q
return (1); Header NULL
}

Empty Queue
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

EnQueue Operation
It is the process of inserting a new element at the Rear end of the Queue.
It takes two parameters, EnQueue ( int X , Queue Q ). The elements X to be inserted intothe Queue Q.
Using malloc ( ) function allocate memory for the newnode to be inserted into the Queue.If the Queue is
Empty, the newnode to be inserted will become first and last node in the list. Hence Front and Rear points
to the newnode.
Otherwise insert the newnode in the Rear -> next and update the Rear pointer.

Routine to EnQueue an Element in Queue

void EnQueue ( int X, Queue Q )
{
struct node *newnode;
newnode = malloc (sizeof (struct node));
if (Rear = = NULL)
{
Newnode-> data = X;
Newnode->next = Null;
Q -> next = newnode;\
Front = newnode;
Rear = newnode;
}
else
{
Newnode->data = X;
Newnode->next= NULL;
Rear-> next= newnode;
Rear= newnode;
}
}
Q Q
Header NULL
Header

Empty Queue
Before Insertion

Front Rear

After Insertion
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

(ii) DeQueue Operation

It is the process of deleting the front element from the Queue.It takes one parameter, Dequeue ( Queue Q ).
Always element in the front (i.e) element pointedby Q -> next is deleted always.
Element to be deleted is made
If the Queue is Empty, then deletion is not possible.
If the Queue has only one element, then the element is deleted and Front and Rear pointer ismade NULL to
represent Empty Queue.
Otherwise, Front element is deleted and the Front pointer is made to point to next node in the list. The free
( ) function informs the compiler that the address that temp is pointing to, is unchanged but the data present
in that address is now undefined.
Q

Header

20 30 40 NULL

Front Rear

Routine to DeQueue an Element from the Queue

void DeQueue ( Queue Q )
{
struct node *temp;
if ( Front = = NULL )

else if (Front = = Rear)

{
temp = Front;
Q -> next = NULL;Front = NULL; Rear = NULL;
free ( temp );
}
else
{
temp = Front;
Q -> next = temp -> next;
Front = Front->Next;
free (temp);
}
}
Applications of Queue
1. Serving requests on a single shared resource, like a printer, CPU task scheduling etc.
2. In real life, Call Center phone systems will use Queues, to hold people calling them in anorder, until a
service representative is free.
3. Handling of interrupts in real-time systems. The interrupts are handled in the same orderas they arrive,
First come first served.
4. Batch processing in operating system.
5. Job scheduling Algorithms like Round Robin Algorithm uses Queue.
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Drawbacks of Queue (Linear Queue)

With the array implementation of Queue, the element can be deleted logically only bymoving Front = Front
+ 1.
Here the Queue space is not utilized fully.
To overcome the drawback of this linear Queue, we use Circular Queue.
CIRCULAR QUEUE
In Circular Queue, the insertion of a new element is performed at the very first location of the queue if the
last location of the queue is full, in which the first element comes just after the lastelement.
A circular queue is an abstract data type that contains a collection of data which allowsaddition of data at
the end of the queue and removal of data at the beginning of the queue.
Circular queues have a fixed size. Circular queue follows FIFO principle.
Queue items are added at the rear end and the items are deleted at front end of the circularqueue
Here the Queue space is utilized fully by inserting the element at the Front end if the rearend is full.

Operations on Circular Queue

Fundamental operations performed on the Circular Queue are
Circular Queue Enqueue
Circular Queue Dequeue
Formula to be used in Circular Queue
• For Enqueue
Rear = ( Rear + 1) % ArraySize
• For Dequeue
Front = ( Front + 1) % ArraySize
(i) Circular Queue Enqueue Operation
It is same as Linear Queue EnQueue Operation (i.e) Inserting the element at the Rear end.First check for full
Queue.
If the circular queue is full, then insertion is not possible.Otherwise check for the rear end.
If the Rear end is full, the elements start getting inserted from the Front end.
Routine to Enqueue an element in circular queue
void Enqueue ( int X, CircularQueue CQ )
{
if( Front = = ( Rear + 1 ) % ArraySize)

else if( Rear = = -1 )

{
Front = Front + 1;Rear = Rear + 1; CQ[ Rear ] = X;
}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

else
{
Rear = ( Rear + 1 ) % Arraysize;
CQ[ Rear ] = X;
}
}

Circular Queue DeQueue Operation

It is same as Linear Queue DeQueue operation (i.e) deleting the front element.First check for Empty Queue.
If the Circular Queue is empty, then deletion is not possible.
If the Circular Queue has only one element, then the element is deleted and Front and Rearpointer is initialized to - 1 to
represent Empty Queue.
Otherwise, Front element is deleted and the Front pointer is made to point to next element in theCircular Queue.

F, R
F= -1,R= --1
Routine To DeQueue An Element In Circular Queue
void DeQueue (CircularQueue CQ)
{
if(Front== - 1)

else if(Front==rear)
{
X=CQ[Front];Front=-1;Rear=-1;
}
else{
X=CQ[Front]; Front=(Front+1)%Arraysize;
}}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

DOUBLE-ENDED QUEUE (DEQUE)

In DEQUE, insertion and deletion operations are performed at both ends of the Queue.

Operations on DEQUE
Four cases for inserting and deleting the elements in DEQUE are
1. Insertion At Rear End [ same as Linear Queue ]
2. Insertion At Front End
3. Deletion At Front End [ same as Linear Queue ]
4. Deletion At Rear End
Case 1: Routine to insert an element at Rear end
void Insert_Rear (int X, DEQUE DQ)
{
if( Rear = = Arraysize - 1)

else if( Rear = = -1)

{
Front = Front + 1;Rear = Rear + 1; DQ[ Rear ] = X;
}
else
{
Rear = Rear + 1;DQ[ Rear ] = X;
}
}
Case 2: Routine to insert an element at Front end
void Insert_Front ( int X, DEQUE DQ )
{
if( Front = = 0 )

else if(Front = = -1)

{
Front = Front + 1;Rear = Rear + 1; DQ[Front] = X;
}
else
{
Front = Front - 1;DQ[Front] = X;
}
}
 CS4301-Data Structures and Algorithms 1 Department of CSE 2023-2024

Case 3: Routine to delete an element from Front end

void Delete_Front(DEQUE DQ)

{
if(Front = = - 1)

else if( Front = = Rear )

{
X = DQ[ Front];Front = - 1; Rear = - 1;
}
else
{
X = DQ [ Front ];Front = Front + 1;
}
}
Case 4: Routine to delete an element from Rear end
void Delete_Rear(DEQUE DQ)
{
if( Rear = = - 1)
Error( “Empty Queue !!! Deletion not possible”);
else if( Front = = Rear )
{
X = DQ[ Rear ];
Front = - 1; Rear = - 1;
}
else
{
X = DQ[ Rear ];
Rear = Rear - 1;
}
}