UNIT 2

DATA
STRUCTURE

MI000000I
11000 00LLL
000 0000IO0 11 óc00001
1 10
Created By
10 0O0I0 111000I00111
1000 0000
000

EEPAK MODI I00

111001OI00010
 NotesNeo

Unit 2: Stacks and Queues

Syllabus:
Stacks: Stack and its operations: Algorithms and their complexity analysis, Applications of Stacks:
Expression Conversion and evaluation -corresponding algorithms and complexity analysis.
Queue: Queue and Types of Queue: Simple Queue, Circular Queue, Priority Queue; Operations on
each type of Queue: Algorithms and their analysis.

Section 1: Stacks

1.1Stack Definition
A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle, where
the last element added is the first one to be removed. Stacks can be efficiently implemented
using arrays or linked lists.
Imagine a stack of plates. You add plates to the top of the stack and remove them from the
top. The last plate you put on the stack is the first one you take off.

Stack overflow error occurs when an attempt is made to push an element onto a full stack.
Stack underflow occurs when an attempt is made to pop an element from an empty stack.

" Initialising a Stack (C Language):

#define MAX_SIZE 100 I/ Define maximum stack size
int [MAX_SIZE]: // Initialize an integer array for the stack
Lnt top = -1: // Initialize the top pointer to -1 to indicate an empty stack

Stack Implementation (in C):

#nclude <stdio.h
#define MAX_ SIZE 100// Maximum size of the stack

1/ Define a structure for the stack

struct
int arr [MAX_SIZE]; 17 Array to store stack elements
int top: // Index of the top element
Pop
Push

Last
/ Function to initialize an empty stack
in
void initialize (struct Stack * first
D
->top =1; // Initialize top to -1 (empty stack) out
C
(LIFO)
B
/ Function to check if the stack is empty
int isEmpty (struc Stack *
STACK
return ->top ==

/ Function to check if the stack is ful11

int isFull(struct Stack *

2
 NotesNeo
returIE ->top MAX_SIZE 1:

// Function to push an element onto the stack

void push(struc Stack * int value)
(isFull (
retur
)
Stack overfloW. Cannot push element %d. \n value): (3
->arr [++ ->top] = value; // Increment top and insert the element
(Pushed %d onto the stack. \n", value):

/1 Function to pop an element from the stack

int pop (struct Stack
(isEmpty )
(Stack underflow. Cannot pop from an empty stack.in"):
return-1; // Return a sentinel value for error

int poppedValue = ->arrl ->top--]; // Get and decrement top

return poppedValue;

/ Function to peek at the top element of the stack without removing it

nt peek(struct Stack * ) {
1f (isEmpty( ){
(Stack is empty. Cannot peek. \n ):
return -1; /7 Return a sentinel value for error
retuuEn
->arr[ ->top]:
TES
int main) {
struct
initialize (&

push(&
push(&
push (&
10);
20);
30):
):1
EO
Top element : %d\n", peek(& )):

(Popped: %d\n, pop(&

(Popped: %d\n", pop(& )):

("Is the stack enpty? %s\n", isEmpty(& ) ? "Yes" : "No):

return 8:
 NotesNeo
1.2 Stack Operations
1. Push: Adds an element to the top of the stack.
2. Pop: Removes the top element from the stack.
3. Peek/Top:Returns the top element without removing it. 3
4. isEmpty: Checks if the stack is empty.
1. Push:

Operation: The "push" operation is used to add an element onto the stack. When you push
an item onto the stack, it becomes the new top element.
Algorithm for Push Operation:
1) Check if the stack is full (in the case of a fixed-size stack).
2) If the stack is not full, increment the top pointer.
3) Place the new element at the top position in the stack.
4) If the stack is full, show the stack overflow error.

Code for Push Operation (C Language):

void push (int item)
if (top MAX_SIZE - 1)
printf("Stack Overflow\n"):
return:

stack [++top] = item;

Complexity Analysis: The "push" operation takes constant time, O(1), as it involves a simple
increment of the top pointer, regardless of the stack's size.
2. Pop:
" Operation: The "pop" operation is used to remove the top element from the stack. When
you pop an item from the stack, it removes the top element and returns it.

" Algorithm for Pop Operation:

1) Check if the stack is empty.
2) If the stack is not empty, return the element at the top.
3) Decrement the top pointer.
4) If the stack is empty, show the stack underflow error.

Code for Pop Operation (C Language):

int pop()
1f (top -1)
printf"Stack Underflow\n"):
return -1:

return stack[ top- -]:

Complexity Analysis: The "pop" operation takes constant time, O(1), as it involves a simple
decrement of the top pointer, regardless of the stack's size.

4
 NotesNe0
3. Peek/Top:
Operation: The "peek" or "top" operation is used to view the top element without removing
it. It allows you to see the element currently at the top of the stack without modifying the
stack itself.
Algorithm: Return the element at the top of the stack without removing it.
Code (C Language): 4
int peek ()
if (top -1)
printf("'Stack is empty\n")A
return -1:

return stack [topl:

Complexity Analysis: The "peek" operation takes constant time, O(1), as it directly accesses
the top element.
4. IsEmpty:
Operation: The "isEmpty" operation is used to check if the stack is empty. It returns true if
the stack contains no elements and false otherwise.
Algorithm: Check if the top pointer is -1, indicating an empty stack.
Code (C Language):
int isEmpty() {
return top == -1

OTES
Complexity Analysis: The isEmpty operation has a constant time complexity of O(1). It
performsa single comparison to check the top pointer, regardless of the stack's size.
5. IsFull (for fixed-size stacks):
Operation: The "isFull" operation is used to check if the stack is full in the case of a
fixed-size stack. It returns true if the stack has reached its maximum capacity and false
otherwise.
Algorithm:Check if the top pointer is equal to the maximum allowed index, indicating that
the stack is full.
Code for IsFull Operation (C Language):
int isFull()
return top == MAX_SIZE - 1:

Complexity Analysis: The isFull operation also has a constant time complexity of O(1). It
performs a single comparison to check the top pointer, regardless of the stack's size.

Section 2: Applications of Stacks

Stacks are a powerful data structure that can be used to implement a wide range of features:
Function calls: Stacks are used to implement function calls in C. When a function is called,
the arguments to the function are pushed onto the stack. When the function returns, the
arguments are popped off the stack.

5
 NotesNeo
Recursion: Stacks are used to implement recursion in C. When a recursive function calls
itself, the parameters to the recursive call are pushed onto the stack. When the recursive
call returns, the parameters are popped off the stack.
Undo/redo: Stacks can be used to implement undolredo functionality in C. When an
operation is performed, the state of the program is pushed onto the stack. To undo the
operation, the state of the program is popped off the stack and restored.
Browsing history: Stacks can be used to implement browsing history in web browsers.
When a user visits a new web page, the URL of the page is pushed onto the stack. When
the user goes back or forward in their browsing history, the URLS are popped off the stack
and loaded.
Expression evaluation: Stacks are used to evaluate expressions in C. The operands of an 5
expression are pushed onto the stack, and the operators are applied to the operands in the
stack.
Reversing a string
Sorting a aray

2.1Expression Conversion
Infix notation is the standard mathematical notation we use every day, e.g.. 3 + 4. Postfix
(Reverse Polish Notation) and Prefix (Polish Notation) notations are alternative notations
for mathematical expressions. We'll discuss converting infix expressions to postfix and
prefix notations.

Polish notation is a mathematical notation in which every operator follows all of its
operands. This eliminates the need for parentheses and precedence to indicate the order of
operations.
In Polish notation, the order of operations is completely determined by the position of the
operators. There are two main forms of Polish notation:
1. Prefix Notation:
In prefix notation, the operator precedes its operands.
For example, the infix expression "3 + 4*5" would be written in prefix notation as "+
3*4 5".

2. Postfix Notation:
" In postfix notation, the operator follows its operands.
For example, the infix expression "3 + 4*5" would be written in postfix notation as
"3 45* +".

Expression conversion involves transforming mathematical expressions from one form to another,
such as converting from infix notation to postfix or prefix notation. Stacks play a crucial role in this
process.
Infix to Postfix Conversion:
o Algorithm:
1. Initialize an empty stack for operators.
2. Scan the infix expression from left to right.
3. If an operand is encountered, output it.
4. If an operator is encountered:
a. Pop operators from the stack and output them until an operator with
lower precedence is at the top or the stack is empty.
b. Push the current operator onto the stack.

6
 NotesNe0
5. After scanning the expression, pop and output any remaining operators from
the stack.
Example:
Infix: a +b*c
Postfix: a bc* +
o Example:
Infix: (A+(B*C-(D/E-F)*G)*H)
Postfix: ABC*DE/F-G*-H*+

Steps Symbol Stack Postfix Expression

6
1. (
2. A ( A

3 +
(+ A

4 ( (+( A

5. B (+( AB

6 (+(* AB

7 C (+(* ABC

8 (+( ABC*

9 (+(-( ABC*
ES
10. D (+(-( ABC*D

11. (+(-(/ ABC*D

12. E (+(-0 ABC*DE

13. (+(-( ABC*DE/

14. F
(+(-( ABC*DE/F

15. ) (+( ABC*DE/F

16. (+(-* ABC*DE/F

17. (+(-* ABC*DE/F-G

18. ) (+ ABC*DE /F-G*

19. (+* ABC*DE/E-G*
20. H (+* ABC*DE/E-G*-H

21. ABC*DE /E-G*-H*+

22. ABC*DE/F-G*-H*+

7
 NotesNeo

Infix to Prefix Conversion:

o Similar to the infix to postfix conversion, but the output is generated in reverse order.
o Algorithm:
1. Initialize an empty stack for operators.
2. Scan the infix expression from right to left.
3. If an operand is encountered, output it.
4. If an operator is encountered:
a. Pop operators from the stack and output them until an operator with
lower or equal precedence is at the top, or the stack is empty.
b. Push the current operator onto the stack.
5. After scanning the expression, pop and output any remaining operators from 7
the stack.
o Example:
Infix: a+b*c
Prefix: *a*bc

" Postfix to Infix Conversion:

o Algorithm:
1. Initialize an empty stack for operands.
2. Scan the postfix expression from left to right.
3. If an operand is encountered, push it onto the stack.
4. If an operator is encountered, pop two operands from the stack, enclose
them in parentheses, and push the resulting expression back onto the stack.
5. After scanning the expression, the top of the stack contains the infix
expression.
o Example:
I Postfix: 3 45+
Infix: (3*4)+5

" Prefixto Infix Conversion:

o Similar to the postfix to infix conversion, but the scan is performed from right to left.
o Algorithm:
1. Initialize an empty stack for operands.
2. Scan the prefix expression from right to left.
3. If an operand is encountered, pushit onto the stack.
4. If an operator is encountered, pop the required number of operands from the
stack, apply the operator, and push the result back onto the stack.
5. After scanning the expression, the result is on the top of the stack.
o Example:
Prefix: +*345
Infix: (3*4)+5

2.2 Expression Evaluation

Stacks are also used to evaluate mathematical expressions in various notations, including postfix
and prefix.
Postfix Expression Evaluation:
o Algorithm:
 NotesNeo
1. Initialize an empty stack for operands.
2. Scan the postfix expression from left to right.
3. If an operand is encountered, push it onto the stack.
4. If an operator is encountered, pop the required number of operands from the
stack, apply the operator, and push the result back onto the stack.
5. After scanning the expression, the result is on the top of the stack.
o Example:
Postfix:34*5+
Evaluation: (3 *4) +5= 17
o Example:
Postfix: 5 62 + * 12 41
Evaluation: 37

Symbol Action Stack

5 Push 5 onto the stack 5 8

6 Push 6 onto the stack 5, 6

2 Push 2 onto the stack 5, 6, 2

+ Pop 6 and 2, push 8 5, 8

Pop 5 and 8, push 40 40

12 Push 12 onto the stack 40, 12

4 Push 4 onto the stack 40, 12, 4

Pop 12 and 4, push 3 40, 3

Pop 40 and 3, push 37 37

" Prefix Expression Evaluation:

o Algorithm:
1. Initialize an empty stack for operands.
2. Scan the prefix expression from right to left.
3. If an operand is encountered, push it onto the stack.
4. If an operator is encountered, pop the required number of operands from the
stack, apply the operator, and push the result back onto the stack.
5. After scanning the expression, the result is on the top of the stack.
o Example:
Prefix: +*345
1 Evaluation: (3 *4) +5= 17
Section 3: Queues

3.1 Queue Definition

A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. It
means that the element added first will be the first one to be removed.
 NotesNeo

return 0:

3.2 Queue Operations

1. Enqueue: Adds an element to the rear of the queue.
2. Dequeue: Removes an element from the front of the queue.
3. Front: Returns the front element without removing it.
4. isEmpty: Checks if the queue is empty.
1. Enqueue:
Operation: The "enqueue" operation is used to add an element to the rear (end) of the
queue. When you enqueue an item, it becomes the last element in the queue.
Algorithm for Enqueue Operation:
1) Check if the queue is full (in the case of a fixed-size queue).
2) If the queue is not full, increment the rear pointer.
3) Place the new element at the rear position in the queue.

" Code for Enqueue Operation (C Language):

void enqueue (int item)
if (rear = MAX_SIZE 1)
printf("Queue Overflow\n"):
return:

queue [++rear]= item;

OTES
Complexity Analysis: The "enqueue" operation takes constant time, O(1), as it involves a
11
simple increment of the rear pointer, regardless of the queue's size.

2. Dequeue:
" Operation: The "dequeue" operation is used to remove and return the front (first) element
from the queue. Dequeuing an item removes the front element and returns it.
Algorithm for Dequeue Operation:
1) Check if the queue is empty.
2) If the queue is not empty, return the element at the front.
3) Increment the front pointer.

" Code for Dequeue Operation (C Language):

int dequeue ()
if (front > rear)
printf("Queue Underflow\n"):
return -1:

return queue [front++] :

12
 NotesNeo
It can be efficiently implemented using arrays or linked lists.
Think of a queue in a real-world scenario like people waiting in line. The person who arrives
first is served first.

First in first out (FIFO) Enqueue

A B D F

QUEUE
Dequeue
Initialising a Queue(C Language):
define MAX SIZE 100 // Define maximum queue size
int queue[MAX_SIZE]: // Initialize an integer array for the queue
int front =-1; // Initialize the front pointer to -1
int rear = -1; 1/ Initialize the rear pointer to -1

Queue Implementation (Simple Queue) in C:

#nclude <stdio.h
#define MAX_SIZE 100 // Maximum size of the queue

7/ Define a structure for the queue

Struct

int arr [MAX_SIZE]; 1/ Array to store queue elements

int front, rear; 11 Indices for front and rear of the queuel

/ / Function to initialize an empty queuel

T
void initialize(struct Queue* )4
->front = -1; 11 Initialize front to -1 (empty queue)
->rear= -1; I/ Initialize rear 1 (empty queue)

/ Function to check if the queue is empty

int isEmpty (struct Queue *
return ->front =

/ Function to check if the queue is ful1

int isFull(struct Queue *
return ( ->rear + 1) % MAX_SIZE == -front:

7/ Function to enqueue (push) an element into the queue

MOid enqueue (struc Queue* int value)
(isFull( ))
Queue is full. Cannot enqueue element %d.\n, value):
return;

(isEmpty(

10
 NotesNeo
-front = ->rear = 0; // Initialize front and rear for the
first element
}else {
->rear = ->rear + 1) % MAX_SIZE; // Circular increment of
rear

->arr[ ->rear]= value;

(Engueued kd into the queue.\n", value):

/ Function to dequeue (pop) an element from the queue

int dequeue(struct Queue * ) {
(isEmpty( )
(Queue is empty. Cannot dequeue from an empty queue. \n" ):
return -1; /1 Return a sentinel value for error

int dequeuedValue = ->arr[ -front]:

1f (C ->front == ->rear)
1/ Queue becomes empty after dequeueing the last element
-front = ->rear 1
} else
->front ->front + 1) % MAX_SIZE; // Circular increment of
front
10

OTES
return dequeuedValue;

/ Function to peek at the front element of the queue without removing it

int peek(struct Queue * )
(isEmpty( )
("Queue is empty. Cannot peek.n"):
return -1; // Return a sentinel value for error

Lnt
return

main () {
Struct
->arrl ->front ]:
EO
initialize(&
enqueue (&
enqueue(&
enqueue (&

(Front element: %d\n", peek(&

("Dequeued: %d\n", dequeue (& ):

(Dequeued: %d\n, dequeue (& )):

(Is the queue empty? %s\n, isEmpty(& ) ?"Yes" : "No ):

11
 NotesNeo
Complexity Analysis: The "dequeue" operation takes constant time, O(1), as it involves a
simple increment of the front pointer, regardless of the queue's size.
3. Front:

Operation: The "front" operation is used to view the front (first) element of the queue
without removing it. It allows you to see the element currently at the front of the queue
without altering the queue itself.
Algorithm for Front Operation:
Return the element at the front of the queue without modifying the queue itself.
Code for Front Operation (C Language):
int front() {
if (front > rear){
printf("Queue is empty\n"):
return-1:

return queue [front] ;

Complexity Analysis: The "front" operation takes constant time, O(1), as it directly accesses
the front element.

4. IsEmpty:
" Operation: The "isEmpty" operation is used to check if the queue is empty. It returns true if
the queue contains no elements and false otherwise.
Algorithm:
Check if the front pointer is greater than the rear pointer, indicating an empty queue.
Code for IsEmpty Operation (C Language):
int isEmpty () 12
return front > rear:

Complexity Analysis: The "isEmpty" operation takes constant time, O(1), as it performs a
single comparison to check the front and rear pointers.

5. IsFull (for fixed-size queues):

Operation: The "isFull" operation is used to check if the queue is full in the case of a
fixed-size queue. It returns true if the queue has reached its maximum capacity and false
otherwise.
Algorithm:
Check if the rear pointer is equal to the maximum allowed index, indicating that the queue
is full.
Code for IsFull Operation (C Language):
int isFull() {
return rear == MAX_SIZE 1:

Complexity Analysis: The "isFull" operation takes constant time, O(1), as it performs a
single comparison to check the rear pointer, regardless of the queue's size.

13
 NotesNeo
3.3 Types of Queues
1. Simple Queue: A simple queue is a basic queue where elements are inserted (enqueued)
at the rear and removed (dequeued) from the front in a First-In-First-Out (FIFO) order.
Example: Imagine people waiting in line at a ticket counter. The person who arrives
first gets the ticket first.

2. Circular Queue: A circular queue is similar to a simple queue but with a circular
arrangement of elements. It efficiently reuses space, and the rear and front pointers wrap
around.
Example: Think of a circular track where runners complete laps. When the last
runner reaches the end, they start from the beginning.

3. Priority Queue: A priority queue assigns priorities to elements and processes them based
on their priority levels, not necessarily in the order they were added. That means elements
are dequeued based on their priorities.
Example:in an hospital emergency room, patients are treated based on the severity
of their condition rather than the order of arrival. Critical patients are given higher
priority.

3.4 Simple Queue

A simple queue is a basic form of a gueue data structure that follows the First-In-First-Out (FIFO)
principle. Elements are inserted (enqueued) at the rear and removed (dequeued) from the front in
the order they were added.

Operations:
1. Enqueue (Insertion):
" Algorithm:
OTES
Check if the queue is full.
If the queue is not full, increment the rear pointer.
Place the new element at the rear position in the queue.
C Code: 13
item)
(rear == MAX_SIZE -
printf("Queue Overflow\n"):
return:

queue[++rear] 1tem;

Time Complexity: O(1) - constant time, as it involves a simple increment of the rear
pointer, regardless of the queue's size.

2. Dequeue (Deletion):
Algorithm:
" Check if the queue is empty.
If the queue is not empty, return the element at the front.
Increment the front pointer.
C Code:

14
 NotesNeo
Lnt deuUele() {
1f (front > rear) {
printf("Queue Underflow\n"):
return

return queue [front++];

Time Complexity: O(1) - constant time, as it involves a simple increment of the front
pointer, regardless of the queue's size.

3. Front (Peek):
Algorithm:
Return the element at the front of the queue without modifying the queue
itself.
C Code:
()
(front > rear)
printf("Queue is empty\n");
TetuN

return queue[front]:

Time Complexity: O(1) - constant time, as it directly accesses the front element.

4. IsEmpty:
Algorithm:
OIES
Check if the front pointer is greater than the rear pointer, indicating an empty
queue.
C Code:

return front > rear:

EO
Time Complexity: O(1) - constant time, as it performs a single comparison to check
the front and rear pointers.

Full Code:

14
#include <stdio . h>

define MAX_SIZE 100

queue[ MAX_SIZE]:
front =
rear =

( t item)
(rear == MAX_SIZE

15
 NotesNeo
printf("Queue Overflow\n") :
return:

queue ++rear] = item;

(front > rear)

printf("Queue Underflow\n"):
return

return queue [front++] :

1f (front > rear) {

printf("Queue is empty\n"):
Teturn

return queue[front]:

() {

OTES
return front > rear;

) {
1/ Sample usage of the simple queue
enqueue
enqueue ):

printf("Front element: %d\n" front ():

printf(" Dequeued: %d\n'", dequeue() ) ;

printf(" Dequeued: %d\n", dequeue(0):
printf("Is the queue empty? %s\n", isEmpty() ? "Yes" : "No"

return

3.5 Circular Queue

A circular queue is similar to a simple queue, but with a circular arrangement of elements. It
efficiently reuses space, and the rear and front pointers wrap around when they reach the end of 15
the queue.

Operations:

16
 NotesNe0
1. Enqueue (Insertion):
" Algorithm:
Check if the queue is full.
If the queue is not full, increment the rear pointer (considering circular
wrapping).
Place the new element at the rear position in the queue.
CCode:
item){
1f ((rear + ) % MAX_SIZE == front )
printf"Queue Overflow\n" )
return;

rear=(rear + ) % MAX_SIZE :

queue[rear] = item;

Time Complexity: O(1) - constant time, as it involves a simple increment of the rear
pointer with circular wrapping.

2. Dequeue (Deletion):
" Algorithm:
Check if the queue is empty.
If the queue is not empty, return the element at the front.
Increment the front pointer (considering circular wrapping).

OTES
CCode:
) {
1f (front ==
printf("Queue Underflow\n"):
return

dequeuedValue = queue[front ] :
1f (front == rear)
1/ Queue becomes empty after dequeueing the last
element
front= rear
}else
front = (front + ) % MAX_SIZE;

return dequeuedValue;

Time Complexity: O(1) - constant time, as it involves a simple increment of the front
16
pointer, regardless of the queue's size.

3. Front (Peek):
Algorithm:
Return the element at the front of the queue without modifying the queue
itself.
CCode:
17
 NotesNe0

1f (front ==
printf("Queue is empty\n"):
Tetun

return queue[front ]:

Time Complexity: O(1) - constant time, as it directly accesses the front element.

4. IsEmpty:
Algorithm:
" Check if both the front and rear pointers are -1, indicating an empty circular
queue.
C Code:

return front = &8 rear

Time Complexity: O(1) - constant time, as it performs a single comparison to check

the front and rear pointers.

5. IsFull:
Algorithm:
o Check if the next position of the rear pointer is equal to the front pointer,
indicating a full circular queue.
Ccode:

return (rear + ) % MAX_SIZE == front;

Time Complexity: O(1) - constant time, as it performs a single comparison to check

the rear and front pointers.

Full Code:

#nclude <stdio.h
EO
#define MAX_SIZE 100

queue[MAX_SIZE ]:
front =
rear =

1nt item)
1f ((rear + ) % MAX_SIZE = front) {
printf("Queue Overflow\n"):
retun: 17
(front ==

18
 NotesNe0
printf("Is the queue empty? %s\n", isEmpty () ? "Yes" : "No") :

3.6 Priority Queue

A priority queue is a type of queue in which elements are assigned priorities, and the element with
the highest priority is dequeued first. Priority queues are often implemented using heaps, a
specialized tree-based data structure.
Operations:
1. Enqueue (Insertion):
Algorithm:
Insert an element with its associated priority into the priority queue.
The element is placed based on its priority level, maintaining the order of
priorities.
C Code:
Struct Node
value;
priority:

(struct Node item)

1f (rear == MAX_SIZE-) {
printf("Queue Overflow\n"): TES
rear++;
1 = rear;
vhile (i > && item.priority > queue [i - ].priority) {
queueli = queue[i ]:1

queue [i] = item;

Time Complexity: O(n) in the worst case, as inserting an element with higher priority
might require shifting existing elements.

2. Dequeue (Deletion):
Algorithm:
Remove and return the element with the highest priority.
C Code:
uct Node
(front > rear) {
printf("Queue Unde rflow\n") :

20
19
 NotesNeo
1/ If the queue is empty, set front to
front

rear = (rear + ) % MAX_SIZE;

queue[rear] = item;

(front ==
printf("Queue Underflow\n"):
return

dequeuedValue = queue[front ];
1f (front == rear)
1/ Queue becomes empty after dequeueing the last element
front rear=

} else{
front = (front + ) % MAX_SIZE;

return dequeuedValue ;

1f (front ==
printf("Queue is empty\n"):
TetuN

return queue[front]:
OTES
return front == && rear ==

Teturn (rear ) % MAX_SIZE == front;

11 Sample usage of the circular queue

enqueue( ):
enqueue( ):

printf("'Front element: %d\n", front (0):

printf("Dequeued: %d\n", dequeue());

printf("Dequeued: %d\n", dequeue ());

19

(
18
 NotesNeo
Struct Node emptyNode

return emptyNode;

queue [front++]:

Time Complexity: O(1) - constant time for removing the highest priority
element.

3. Front (Peek):
Algorithm:
Return the element at the front of the priority queue (highest priority) without
modifying the queue itself.
" C Code:
struct Node
1f (front > rear) {
printf("Queue is empty\n") ;
Struct Node emptyNode ={
ode o
return emptyNode;

return queue[front] :

Time Complexity: O(1) - constant time, as it directly accesses the highest priority
element.

4. IsEmpty:
Algorithm:
" Check if the priority queue is empty.
C Code:
){
return front > rear:

Time Complexity: O(1) - constant time for checking if the queue is empty.

Full Code:

#include <stdio.h>

det MAX_SIZE 100

struct Node {
value;
priority:

21
 NotesNeo
struct Node queue[MAX_SIZE]:
front
rear =

(Struct Node item) 4

(rear == MAX_SIZE
printf("Queue Overflow\n") :
return:

rear++;
Lnt i = rear;
while (i > && item.priority > queue[i - ]-priority) {
queue[i] = queueli 11:
i--;

queue i = item;

struc Node

(front rear){
printf ("Queue Underflow\n"):
struct Node emptyNode 1}; // Return an empty node for
error
return emptyNode;

return queue[front++] : OTES

struct Node
(front rear)
printf ("Queue is empty\n"):
Struct Node emptyNode = { 1}; 17 Return an empty node for
error
return emptyNode;

return queue[front] :

(){
front > rear;

1/ Sample usage of the priority queue

struct Node item1 = {10, 2}:
struct Node item2 = { , }:

enqueue (item1):
22
 NotesNeo
enqueue(item2)

printf ("Front element : value=%d, priority=%d \n", front () . value,

front ().priority):

printf("Dequeued: value=%d, priority=%d\n", dequeue () . value,

dequeue() -priority) ;
printf("Dequeued: value=%d, priority=%d \n", dequeue().value,
dequeue).priority):

printf("Is the queue empty? %s\n", isEmpty() ? "Yes" "No"):

etUTT

3.7 Simple (Linear) Queue vs Circular Queue

Feature Linear Queue Circular Queue

Arrangement of Elements are arranged in a Elements are arranged in a circular or
Elements straight line. ring structure.
Pointer Front and rear pointers may need Front and rear pointers naturally wrap
Management resetting when reaching the end. around when reaching the end.

Space Utilization May experience wasted space at Efficiently reuses space by

connecting the last element to the
the end after dequeuing elements. first.

Implementation May require more complex logic Simplified implementation due to the
Complexity for pointer management. circular structure.
Commonly used in scenarios Suitable for applications with cyclical
Use Cases where elements are processed in behavior, circular buffers, and tasks
the order they are added. repeating in cycles.
Enqueue and dequeue operations Enqueue and dequeue operations
Performance may require more pointer can be more efficient with
adjustments. constant-time pointer adjustments.
Memory May result in memory Less likely to result in memory
Management fragmentation over time. fragmentation.
Examples Supermarket checkout, printer Round-robin scheduling, circular
queue. buffer in communication systems.

23
 NotesNeo

MDU Previous Year Questions

1. What do you mean by stack. Describe dynamic implementation (linked list based) of a
stack. Also write algorithm to perform push and pop operation on stack.
2. Describe the various applications of stack data structure.
3. Explain Polish notation.
4. Write an algorithm to transform from prefix to postfix expression.
5. Translate the given infix expression to postfix expression. Also give the relevant algorithm.
(A+ (B*C -(D/E-F) *G) *H)
6. Convert the following infix expression into postfix:
((A+ B) -C*(D/E)) +F
7. Evaluate the expression: P = 562 + *12 4/

8. Explain the types of Queues and implementation of queues using arrays.

9. What is Queue Data Structure ? Explain its various types with standard operations
performed on them.
10. Explain the circular queue. How is it different from a linear queue ? Write a program to add
and delete element in a circular queue.
11. What are the advantages of using the Circular queue ? How is it different from a normal
queue ? Also explain its algorithm.
12. What is the Priority queue ?

OTES
EO

24
24