DATA STRUCTURES

UNIT – III
QUEUES
INTRODUCTION TO QUEUES
 Queue is a linear data structure that permits insertion of new
element at one end and deletion of an element at the other end.
 The end at which the deletion of an element take place is called
front, and the end at which insertion of a new element can take place
is called rear.
 The deletion or insertion of elements can take place only at the front
or rear end called dequeue and enqueue.
 The first element that gets added into the queue is the first one to get
removed from the queue.
 The queue is referred to as First-In-First-Out list (FIFO).

REPRESENTATION OF QUEUES (PROPERTIES AND OPERATIONS

PERFORMED ON QUEUES) USING ARRAYS
 There are two possible operations performed on a queue. They are
enqueue and dequeue.
enqueue: Allows inserting an element at the rear of the queue.
dequeue: Allows removing an element from the front of the queue.

Algorithm for enqueue(inserting an element)

1. initialize front = 0,rear = -1.
2. check overflow condition? If front = 0 and rear = max_size then write
overflow and exit.
3. if front = NULL then set front = 0 and rear = 0 else if rear = max_size then
set rear = 0
1
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

4. set rear = rear + 1

5. queue[rear] = element
6. exit

Let us consider a queue, which can hold maximum of five elements.

Initially the queue is empty.

Now, insert 11 to the queue. Then queue status will be:

Next, insert 22 to the queue. Then the queue status is:

Again insert another element 33 to the queue. The status of the queue is:

Again insert another element 44 to the queue. The status of the queue is:

Again insert another element 55 to the queue. The status of the queue is:

2
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Again insert another element 66 to the queue. The status of the queue is:

An element can be added to the queue only at the rear end of the
queue. Before adding an element in the queue, it is checked whether queue
is full. If the queue is full, then addition cannot take place. Otherwise, the
element is added to the end of the list at the rear side.

Algorithm for dequeue (deleting an element)

1. check underflow condition? if front < 0 then write underflow and exit
2. set element = queue[front]
3. if front = rear then set front = rear = NULL else if front = max_size then
set front = 0
4. set front = front + 1
5. exit

Now, delete an element 11. The element deleted is the element at the
front of the queue. So the status of the queue is:

Now, delete an element 22. The element deleted is the element at the front of
the queue. So the status of the queue is:

3
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Now, delete an element 33. The element deleted is the element at the front of
the queue. So the status of the queue is:

Now, delete an element 44. The element deleted is the element at the front of
the queue. So the status of the queue is:

Now, delete an element 55. The element deleted is the element at the front of
the queue. So the status of the queue is:

The dequeue operation deletes the element from the front of the
queue. Before deleting and element, it is checked if the queue is empty. If
not the element pointed by front is deleted from the queue and front is now
made to point to the next element in the queue.

IMPLEMENTATION OF QUEUES USING ARRAYS

 The queues can be implemented by using arrays and linked lists.
 If arrays are used for implementing the queues, it would be very easy
to manage the queues.
 But the problem with an array is that we are required to declare the
size of the array before using it in a program. This means the size of
the queue should be fixed.
#include<stdio.h>
#include <conio.h>
#define MAX 6
int Q[MAX];
4
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

int front, rear;

void insertQ()
{
int data;
if(rear == MAX)
{
printf("\n Linear Queue is full");
return;
}
else
{
printf("\n Enter data: ");
scanf("%d", &data);
Q[rear] = data;
rear++;
printf("\n Data Inserted in the Queue ");
}
}
void deleteQ()
{
if(rear == front)
{
printf("\n\n Queue is Empty..");
return;
}
else
{
printf("\n Deleted element from Queue is %d",Q[front]);
front++;
}
}
void displayQ()

5
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

{
int i;
if(front == rear)
{
printf("\n\n\t Queue is Empty");
return;
}
else
{
printf("\n Elements in Queue are:");
for(i = front; i < rear; i++)
{
printf("%d\t", Q[i]);
}
}
}
int menu()
{
int ch;
clrscr();
printf("\n \tQueue operations using ARRAY..");
printf("\n -----------**********-------------\n");
printf("\n 1. Insert ");
printf("\n 2. Delete ");
printf("\n 3. Display");
printf("\n 4. Quit ");
printf("\n Enter your choice:");
scanf("%d", &ch);
return ch;
}
int main(void)
{

6
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

int ch;
do
{
ch = menu();
switch(ch)
{
case 1:
insertQ();
break;
case 2:
deleteQ();
break;
case 3:
displayQ();
break;
case 4:
return;
}while(ch!=4);
return 0;
}

LINKED QUEUES AND ITS REPRESENTATION

 Queue is a linear data structure that permits insertion of new element
at one end and deletion of an element at the other end.
 The end at which the deletion of an element take place is called front,
and the end at which insertion of a new element can take place is
called rear.
 The deletion or insertion of elements can take place only at the front
or rear end called dequeue and enqueue.
 The first element that gets added into the queue is the first one to get
removed from the queue.
 Hence the queue is referred to as First-In-First-Out list (FIFO).

7
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

 We can perform the similar operations on two ends of the list using
two pointers front pointer and rear pointer.

PROPERTIES AND OPERATIONS ON QUEUES USING LINKED

LIST
Enqueue operation
 In linked list representation of queue, the addition of new element to
the queue takes place at the rear end.
 It is the normal operation of adding a node at the end of a list.

Algorithm for enqueue(inserting an element)

Allocate memory for the temporary node and name it as temp
set temp - > data = value
set temp -> next = NULL
if (front = NULL) then
set rear = front = temp
set rear - > next = front -> next = NULL
else
set rear - > next = temp
set rear = rear - > next
set rear -> next = NULL

8
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Dequeue operation
 The dequeue operation deletes the first element from the front end of
the queue.
 Initially it is checked, if the queue is empty.
 If it is not empty, then return the value in the node pointed by front,
and moves the front pointer to the next node.

Algorithm for dequeue(deleting an element)

if (front = NULL)
display “Queue is empty”
return
else
while(front != NULL)
temp = front
front = front - > next
free(temp)

IMPLEMENTATION OF QUEUES USING LINKED LIST

#include<stdio.h>
#include <stdlib.h>
struct queue
{
int data;
struct queue *next;
};
9
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

typedef struct queue node;

node *front = NULL;
node *rear = NULL;
node* getnode()
{
node *temp;
temp = (node *) malloc(sizeof(node)) ;
printf("\n Enter data ");
scanf("%d", &temp -> data);
temp -> next = NULL;
return temp;
}
void insertQ()
{
node *temp;
temp = getnode();
if(temp == NULL)
{
printf("\n Queue Full");
return;
}
if(front == NULL)
{
front = temp;
rear = temp;
}
else
{
rear -> next = temp;
rear = temp;
}
printf("\n\n\t Data Inserted into the Queue..");

10
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

}
void deleteQ()
{
node *temp;
if(front == NULL)
{
printf("\n\n\t Empty Queue..");
return;
}
temp = front;
front = front -> next;
printf("\n\n\t Deleted element from queue is %d ", temp ->data);
free(temp);
}
void displayQ()
{
node *temp;
if(front == NULL)
{
printf("\n\n\t\t Empty Queue ");
}
else
{
temp = front;
printf("\n\n\n\t\t Elements in the Queue are: ");
while(temp != NULL )
{
printf("%5d ", temp -> data);
temp = temp -> next;
}
}
}

11
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

char menu()
{
char ch;
clrscr();
printf("\n \t..Queue operations using pointers.. ");
printf("\n\t -----------**********-------------\n");
printf("\n 1. Insert ");
printf("\n 2. Delete ");
printf("\n 3. Display");
printf("\n 4. Quit ");
printf("\n Enter your choice: ");
ch = getche();
return ch;
}
int main(void)
{
char ch;
do
{
ch = menu();
switch(ch)
{
case '1' :
insertQ();
break;
case '2' :
deleteQ();
break;
case '3' :
displayQ();
break;
case '4':

12
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

return;
}
} while(ch != '4');
return 0;
}

APPLICATIONS OF QUEUES
 Queues are widely used as waiting lists for a single shared resource
like printer, disk, CPU.
 Queues are used to transfer data asynchronously (data not
necessarily received at same rate as sent) between two processes (IO
buffers), e.g., pipes, file IO, sockets.
 Queues are used as buffers on MP3 players and portable CD players,
iPod playlist.
 Queues are used in Playlist for jukebox to add songs to the end, play
from the front of the list.
 Queues are used in operating system for handling interrupts. When
programming a real-time system that can be interrupted, for example,
by a mouse click, it is necessary to process the interrupts
immediately, before proceeding with the current job. If the interrupts
have to be handled in the order of arrival, then a FIFO queue is the
appropriate data structure.
 When multiple users send print jobs to a printer, each printing job is
kept in the printing queue. Then the printer prints those jobs
according to first in first out (FIFO) basis.
 Breadth first search uses a queue data structure to find an element
from a graph.

BREADTH FIRST SEARCH TECHNIQUE (BFT)

To traverse a graph by BFS, first a vertex V 1 in the graph will be
visited then all the adjacent vertices of it will be traversed. Suppose if V 1 has
the adjacent vertices (V1, V2, …..Vn) then they will be printed first and the

13
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

process continues for all vertices. The data structures used for keeping all
vertices and their adjacent vertices is Queue. We also use array for visited
vertices. The nodes that are visited are marked as 1. In BFS, traversing is
done in breadth wise fashion.

Algorithm
1. Create a graph, depending on the type of graph either it may be directed
or undirected set the value of flag to 1 or 0.
2. Read the vertex from which you want to traverse the graph say V i
3. Initialize the visited array to 1 at the index of V i
4. Insert the visited vertex Vi in the queue
5. Visit the vertex which is at the front of the queue, delete it from the queue
and place the adjacent vertices in the queue.
6. Repeat the step5 till queue is not empty.

Step 1: Initialize the queue.

14
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Step 2: Start with the vertex from visiting S (starting node), and mark it as
visited.

Step 3: We then see an unvisited adjacent node from S. In this example, we

have three nodes but alphabetically we choose A, mark it as visited and
enqueue it.

Step 4: Next, the unvisited adjacent node from S is B. We mark it as visited

and enqueue it.

Step 5: Next, the unvisited adjacent node from S is C. We mark it as visited

and enqueue it.

15
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Step 6: Now, S is left with no unvisited adjacent nodes. So, we dequeue S

and find A.

Step 7: Next, the unvisited adjacent node from A is D. We mark it as visited

and enqueue it.

Step 7: Now, A is left with no unvisited adjacent nodes. So, we dequeue A.

Step 8: Now, B is dequeued.

16
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

Step 9: Now, C is dequeued.

Step 10: Now, D is dequeued.

SCHEDULING
“Scheduling is the process of arranging, controlling and optimizing
work and workloads in a production process or manufacturing process”.
It is sometimes called as CPU scheduling. The process of allocating
the amount of CPU time for the process to execute or run for its completion
is called CPU Scheduling. There are two types of scheduling.
Preemptive Scheduling - Preemptive scheduling is used when a process
switches from running state to ready state or from waiting state to ready
state. The resources (mainly CPU cycles) are allocated to the process for the
limited amount of time and then is taken away, and the process is again
placed back in the ready queue if that process still has CPU burst time
remaining. That process stays in ready queue till it gets next chance to
execute.
Non-Preemptive Scheduling - Non-preemptive Scheduling is used when a
process terminates, or a process switches from running to waiting state. In
this scheduling, once the resources (CPU cycles) is allocated to a process,
the process holds the CPU till it gets terminated or it reaches a waiting state.

17
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

In case of non-preemptive scheduling does not interrupt a process running

CPU in middle of the execution. Instead, it waits till the process complete its
CPU burst time and then it can allocate the CPU to another process.

Scheduling Criteria
There are several different criteria to consider when trying to select the
"best" scheduling algorithm for a particular situation and environment,
including:
CPU utilization - Ideally the CPU would be busy 100% of the time, so as to
waste 0 CPU cycles. On a real system CPU usage should range from 40%
(lightly loaded) to 90% (heavily loaded)
Throughput - Number of processes completed per unit time. May range
from 10 / second to 1 / hour depending on the specific processes.
Turnaround time - Time required for a particular process to complete, from
submission time to completion.
Waiting time - How much time processes spend in the ready queue waiting
their turn to get on the CPU.
Response time - The time taken in an interactive program from the
issuance of a command to the commence of a response to that command.

First Come First Serve (FCFS)

 In FCFS Scheduling, the process which arrives first in the ready
queue is firstly assigned the CPU.
 In case of a tie, process with smaller process id is executed first.
 It is always non-preemptive in nature.
 Jobs are executed on first come, first serve basis.
 It is a non-preemptive, pre-emptive scheduling algorithm.
 Easy to understand and implement.
 Its implementation is based on FIFO queue.
 Poor in performance as average wait time is high.

Advantages
 It is simple and easy to understand.

18
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

 It can be easily implemented using queue data structure.

 It does not lead to starvation.

Disadvantages
 It does not consider the priority or burst time of the processes.
 It suffers from convoy effect i.e. processes with higher burst time
arrived before the processes with smaller burst time.

DEQUE
 A deque (pronounced as ‘deck’ or ‘dequeue’) is a list in which the
elements can be inserted or deleted at both ends.
 It is also known as a head-tail linked list because elements can be
added to or removed from both the front (head) or the back (tail) end.
 No element can be added and deleted from the middle.
 In the computer’s memory, a deque is implemented using either a
circular array or a circular doubly linked list.
19
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

 In a deque, two pointers are maintained, front and rear, which point
to either end of the deque.
 The elements in a deque extend from the front end to the rear end
and since it is circular, Dequeue[N–1] is followed by Dequeue[0].
 There are two variants of a double-ended queue. They include
 Input restricted deque:- In this dequeue, insertions can be done only
at one of the ends, while deletions can be done from both ends.
 Output restricted deque:- In this dequeue, deletions can be done only
at one of the ends, while insertions can be done on both ends.

REPRESENTATION OF DEQUE (PROPERTIES AND

OPERATIONS ON DEQUE)
 There are four basic operations in deque:
 Enqueue_front: insert an element at front
 Dequeu_front: delete an element at front
 Enqueue_rear: insert an element at rear
 Dequeue_rear: delete an element at rear
Algorithms
initialize rear = -1, front= -1
initialize n = size
declare array a[n]
isempty()
{
if(front == -1 && rear == -1)
return true
20
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

else
return false
}
isfull()
{
if((rear+1)%N == front)
return true
else
return false
}
enqueuerear(x)
{
if(isfull())
printf(“\n queue is full”);
else if(isempty())
front = rear = 0
else
rear = rear + 1 % N
a[rear]=x
}
dequefront()
{
if(isempty())
printf(“\n queue is empty”);
else if(front == rear)
front = rear = -1
else
front = front +1 % N
}
enqueuefront(x)
{
if(isfull())

21
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
 DATA STRUCTURES

printf(“\n queue is full”);

else if(isempty())
front = rear = 0
else
front = (front + N – 1) % N
a[front]=x
}
dequerear()
{
if(isempty())
printf(“\n queue is empty”);
else if(front == rear)
front = rear = -1
else
rear = (rear + N – 1) % N
}
Example

APPLICATIONS OF DEQUUE
 Applied as both stack and queue, as it supports both operations.
 In O(1) time we can perform clock-wise and anti-clockwise rotational
operations.
 For undo operation in sorting.
 Storing a web browser’s history.
 Storing a software application’s list of undo operations.
 Job scheduling algorithm

22
Dr. Ratna Raju Mukiri M.Tech(CSE)., S.E.T., Ph.D.,
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING