UNIT 3: QUEUE

Queue Data Structure

A queue can be defined as an ordered list which enables insert operations to be performed
at one end called REAR and delete operations to be performed at another end called FRONT.
Queue is referred to be as First In First Out list.

Applications of Queue
 waiting lists for a single shared resource like printer, disk, CPU.
 asynchronous transfer of data
 maintain the play list in media players in order
 operating systems for handling interrupts

Basic Operations on Queue:

 enqueue() – Insertion of elements to the queue.
 dequeue() – Removal of elements from the queue.
 peek() or front()- Acquires the data element available at the front node of the queue
without deleting it.
 rear() – This operation returns the element at the rear end without removing it.
 isFull() – Validates if the queue is full.
 isEmpty() – Checks if the queue is empty.
 size(): This operation returns the size of the queue i.e. the total number of elements it
contains.
Array implementation of queue
To implement a queue using a simple array,
 create an array arr of size n and
 take two variables front and rear which are initialized as 0 and -1 respectively
 rear is the index up to which the elements are stored in the array including the rear
index itself. We mainly add an item by incrementing it.
 front is the index of the first element of the array. We mainly remove the element at
this index in Dequeue operation.

Enqueue
If rear == capacity-1, Overflow condition
Dequeue

If rear == -1, Underflow condition

Here's a simple implementation of a queue using an array in C:

#include <stdio.h>

#define MAX_SIZE 5

// Queue structure

typedef struct {

int data[MAX_SIZE];

int front;

int rear;

int size;

} Queue;

// Function to create a new queue

void createQueue(Queue *q) {

q->front = q->rear = q->size = 0;

}

// Function to check if queue is empty

int isEmpty(Queue *q) {

return q->size = 0;

// Function to check if queue is full

int isFull(Queue *q) {

return q->size = MAX_SIZE;

// Function to enqueue an element

void enqueue(Queue *q, int value) {

if (isFull(q)) {

printf("Queue is full\n");

return;

q->data[q->rear] = value;

q->rear = (q->rear + 1) % MAX_SIZE;

q->size++;

// Function to dequeue an element

int dequeue(Queue *q) {

if (isEmpty(q)) {

printf("Queue is empty\n");

return -1;

}
 int value = q->data[q->front];

q->front = (q->front + 1) % MAX_SIZE;

q->size--;

return value;

// Function to peek at the front element

int peek(Queue *q) {

if (isEmpty(q)) {

printf("Queue is empty\n");

return -1;

return q->data[q->front];

// Function to print queue elements

void printQueue(Queue *q) {

int i = q->front;

for (int count = 0; count < q->size; count++) {

printf("%d ", q->data[i]);

i = (i + 1) % MAX_SIZE;

printf("\n");

int main() {

Queue q;

createQueue(&q);
int choice, value;

while (1) {

printf("\nQueue Operations:\n");

printf("1. Enqueue\n");

printf("2. Dequeue\n");

printf("3. Peek\n");

printf("4. Is Full\n");

printf("5. Is Empty\n");

printf("6. Print Queue\n");

printf("7. Exit\n");

printf("Enter your choice: ");

scanf("%d", &choice);

switch (choice) {

case 1:

printf("Enter value to enqueue: ");

scanf("%d", &value);

enqueue(&q, value);

break;

case 2:

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

break;

case 3:

printf("Front element: %d\n", peek(&q));

break;

case 4:

printf("Is Full: %s\n", isFull(&q) ? "Yes" : "No");

 break;

case 5:

printf("Is Empty: %s\n", isEmpty(&q) ? "Yes" : "No");

break;

case 6:

printf("Queue elements: ");

printQueue(&q);

break;

case 7:

return 0;

default:

printf("Invalid choice\n");

return 0;

Here's the pseudo code for the Queue implementation:

Create Queue

1. Initialize Queue q

2. Set q.front = 0

3. Set q.rear = 0

4. Set q.size = 0

Is Empty

1. If q.size == 0

2. Return True
3. Else

4. Return False

Is Full

1. If q.size == MAX_SIZE

2. Return True

3. Else

4. Return False

Enqueue

1. If Is Full(q)

2. Print "Queue is full"

3. Else

4. q.data[q.rear] = value

5. q.rear = (q.rear + 1) mod MAX_SIZE

6. q.size++

Dequeue

1. If Is Empty(q)

2. Print "Queue is empty"

3. Else

4. value = q.data[q.front]

5. q.front = (q.front + 1) mod MAX_SIZE

6. q.size--

7. Return value

Print Queue
1. For i = q.front to q.size

2. Print q.data[i]

3. i = (i + 1) mod MAX_SIZE

Main

1. Create Queue q

2. Enqueue(q, 1)

3. Enqueue(q, 2)

4. Enqueue(q, 3)

5. Enqueue(q, 4)

6. Enqueue(q, 5)

7. Print Queue(q)

8. Dequeue(q)

9. Print Queue(q)

Queue – Linked List Implementation

#include <stdio.h>

#include <stdlib.h>

// Node structure

typedef struct Node {

int data;

struct Node* next;

} Node;

// Queue structure

typedef struct {

Node* front;
 Node* rear;

} Queue;

// Function to create a new node

Node* createNode(int data) {

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->data = data;

newNode->next = NULL;

return newNode;

// Function to create a new queue

void createQueue(Queue* q) {

q->front = q->rear = NULL;

// Function to check if queue is empty

int isEmpty(Queue* q) {

return q->front == NULL;

// Function to enqueue an element

void enqueue(Queue* q, int data) {

Node* newNode = createNode(data);

if (isEmpty(q)) {

q->front = q->rear = newNode;

} else {

q->rear->next = newNode;
 q->rear = newNode;

// Function to dequeue an element

int dequeue(Queue* q) {

if (isEmpty(q)) {

printf("Queue is empty\n");

return -1;

int data = q->front->data;

Node* temp = q->front;

q->front = q->front->next;

if (q->front == NULL) {

q->rear = NULL;

free(temp);

return data;

// Function to peek at the front element

int peek(Queue* q) {

if (isEmpty(q)) {

printf("Queue is empty\n");

return -1;

return q->front->data;

}
// Function to print queue elements

void printQueue(Queue* q) {

Node* temp = q->front;

while (temp != NULL) {

printf("%d ", temp->data);

temp = temp->next;

printf("\n");

int main() {

Queue q;

createQueue(&q);

int choice, data;

while (1) {

printf("\nQueue Operations:\n");

printf("1. Enqueue\n");

printf("2. Dequeue\n");

printf("3. Peek\n");

printf("4. Print Queue\n");

printf("5. Exit\n");

printf("Enter your choice: ");

scanf("%d", &choice);

switch (choice) {

case 1:
 printf("Enter value to enqueue: ");

scanf("%d", &data);

enqueue(&q, data);

break;

case 2:

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

break;

case 3:

printf("Front element: %d\n", peek(&q));

break;

case 4:

printf("Queue elements: ");

printQueue(&q);

break;

case 5:

return 0;

default:

printf("Invalid choice\n");

return 0;

Pseudo Code

Create Node

1. Create node newNode

2. Set newNode.data to data

3. Set newNode.next to NULL

4. Return newNode

Create Queue

1. Initialize queue q

2. Set q.front to NULL

3. Set q.rear to NULL

Is Empty

1. If q.front is NULL

2. Return True

3. Else

4. Return False

Enqueue

1. Create node newNode with data

2. If q is empty

3. Set q.front to newNode

4. Set q.rear to newNode

5. Else

6. Set q.rear.next to newNode

7. Set q.rear to newNode

Dequeue

1. If q is empty

2. Print "Queue is empty"

3. Return -1

4. Set data to q.front.data

5. Set temp to q.front

6. Set q.front to q.front.next

7. If q.front is NULL

8. Set q.rear to NULL

9. Free temp

10. Return data

Peek

1. If q is empty

2. Print "Queue is empty"

3. Return -1

4. Return q.front.data

Print Queue

1. Set temp to q.front

2. While temp is not NULL

3. Print temp.data

4. Set temp to temp.next

Main

1. Create queue q

2. While true

3. Print menu

4. Get user choice

5. Switch choice

1. Enqueue: Get data, enqueue data

2. Dequeue: Dequeue, print dequeued value

3. Peek: Print front element

4. Print Queue: Print queue elements

 5. Exit: Exit program

Priority Queue

A priority queue is a special type of queue in which each element is associated with
a priority value

Difference between Priority Queue and Normal Queue

In a queue, the first-in-first-out rule is implemented whereas, in a priority queue, the values
are removed on the basis of priority. The element with the highest priority is removed first.

Priority Queue Operations

1. Inserting an Element into the Priority Queue

Insert an element at the end of the queue

Heapify after insertion

Algorithm for insertion of an element into priority queue (max-heap)

If there is no node,
 create a newNode.

else (a node is already present)

insert the newNode at the end (last node from left to right.)

heapify the array

2. Deleting an Element from the Priority Queue

Select the element to be deleted

Swap with the last leaf node element

 Remove the last element leaf

Heapify the priority queue

Algorithm for deletion of an element in the priority queue (max-heap)

If nodeToBeDeleted is the leafNode

remove the node

Else swap nodeToBeDeleted with the lastLeafNode

remove noteToBeDeleted

heapify the array

3. Peeking from the Priority Queue (Find max/min)

return rootNode
 Priority Queue Applications
 Dijkstra's algorithm

 for implementing stack

 for load balancing and interrupt handling in an operating system

Dynamic Memory Allocation Techniques:

1. malloc
int* ptr = (int*) malloc(5 * sizeof(int)); // Allocates memory for 5 integers
2. calloc
int* ptr = (int*) calloc(5, sizeof(int)); // Allocates memory for an array of 5 integers
3. realloc:
int* ptr = (int*) malloc(5 * sizeof(int)); // Allocates memory for 5 integers
ptr = (int*) realloc(ptr, 10 * sizeof(int)); // Reallocates memory for 10 integers