FIFO Approach in data structure

FIFO stands for First In First Out, in which we will enter the data elements into the data structure; the data element added at last in any data structure will be removed out last and the element added first will be removed first. Here, we treat the data elements with a fair chance; the element which has entered first will get the opportunity to leave first. The other name we call First Come First Serve is implemented using the data structure named a queue.

The best example to understand the FIFO principle is when we stand in a queue and want to take a movie ticket, and there are a lot of people standing before us, and we have no other choice left instead of waiting for our chance. If we observe the above example, we can easily see that we will get the chance after the people standing before us and will be treated as first come, first serve.

The FIFO principle has great importance in the various processes scheduling algorithm, which the operating system does to finalize the schedule of several processes one after another.
One of the algorithms that CPU uses is FCFS, first come, first serve to give a fair chance to every process, and it is implemented by using the queue data structure.
In one of the primitive algorithms of scheduling, we will use the round-robin algorithm, and the circular queue has its great importance; by using the circular queue, we will be able to preempt the process and give a fair chance to every process using a circular queue. This algorithm is employed by process and network schedulers in computing.
It is also used in computer-controlled Traffic Signal Systems.
It is also used in CPU scheduling and memory management
The data structure, based on the FIFO principle, is the queue.
In the queue data structure, we will perform the two main operations: first, Enqueue operation for inserting the data elements into the queue, and another is Dequeue operation for removing the data elements from the queue.
In stack, we will mainly use two operations push for pushing the data elements into the stack, and another is pop for removing the elements from the stack.
The queue contains two ends, i.e., the front, and another is the rear
Many programs are based on the concept of the FIFO principle.
A queue is one of the important linear data structures extensively used in various computer applications, and also it is based on the FIFO ( First In First Out ) principle. It follows a particular order of data execution for which operations are performed. In this data structure, data enters from one end, i.e., the REAR end, and the next data enters the queue after the previous one. Deletion operation is performed from another end, i.e., FRONT
As compared with stacks, stacks are also a linear data structure. Although, it is based on LIFO (Last In First Out) principle, which implies that data enters one by one from one end into the stack till it reaches its end limit, and it popped out the data element from the stack from that end itself.
In a stack, only one pointer is needed for performing all operations, which is top, whereas, in the queue, there are two pointers needed, rear and front, for performing all operations.

The approach, as mentioned earlier, is known as the First-In-First-Out approach or FIFO.

Applications of FIFO Approach

The applications of FIFO are as follows:

1) Data Structures

The queue is a linear data structure based on the FIFO approach, in which data elements enter into the queue using the rear end, and from the front end, deletion of elements occurs.

FIFO approach is mostly used in network bridges, switches, and routers.

It is further categorized as linear queue

Linear Queue

A linear queue is a linear data structure based on FIFO (First in First Out) principle, in which data enters from the rear end and is deleted from the front end. A linear queue is said to be the simple queue, and whenever we need to talk about the queue, it is by default set that we are considering a linear queue. We will discuss these ends in more detail further.

Other examples like->

People are waiting for the bus. The first person standing in the queue will be the first to get on the bus.
Cars lined at a toll bridge. The first car to reach the bridge will be the first to leave.

Operations of linear Queue

There are certain basic operations has performed in the linear queue are as follows->

Enqueue
- For the addition of data elements in the queue, this operation is used.
- By applying this operation, data is entered in the queue according to the sequence after one another. Enqueue will be continued till the queue reaches its end limit.
- After it reaches the endpoint, the data cannot add to the queue, and then such condition is said to be an Overflow condition.
- En-queue operation is done from the rear end.
Dequeue
- This operation is used to delete a data element from the queue.
- Using Dequeue operation, that data element is deleted, which is enqueued first in the queue, or the elements are popped in the same order in which they are pushed.
- This process will delete the data elements from the queue until the whole queue becomes empty. Once all the elements are deleted, then the deletion operation is unable to execute, and then such condition is said to be an Underflow condition.
- It is done from the front end.
Peek
This operation is used to find out the very first queue element, which is to be served first without dequeuing it.

Two Ends of Linear Queue

Front end - It refers to the initial or starting position of the queue. The front end is mainly used to delete the data element from the queue or perform a dequeue operation.
Rear-end - refers to the last or back position of the queue. The rear end is mainly used to insert the queue data elements or perform the en-queue operation.

Methods of Implementation of Linear queue

There are various methods of implementation of the queue:

Queue implementation using an array
Queue implementation using stack
Queue implementation using linked list

Implementation of Linear queue using an Array

Here we discuss the implementation of queue using an array->

Queues can easily be implemented by using linear arrays. As stated earlier, the queue has front and rear pointers from which deletion and insertion of data elements can be done.

Steps

Initially, we need to create an array of size 'n' whether statically or dynamically, depending on the user.
Declare two pointers named FRONT and REAR.
Initialize REAR = -1 and FRONT = 0.
Create three functions named Enqueue for adding data elements in the Queue, Dequeue for deletion of a data element from the queue, and peek for finding out the first element from the queue without dequeuing it.

Algorithm of Enqueue operation

Step 1- Check if REAR == FRONT.

Step 2- If the above statement holds, then such a condition is said to be an Overflow, and further insertion of data elements is not possible.

Step 3- If it holds false, then

set REAR = REAR + 1 and
add the data element in queue at rear position.
Queue[REAR] = data.

Algorithm of Dequeue operation

Step 1- Check if FRONT = REAR + 1

Step 2- If the above statement holds, then

such condition is said to be Underflow condition.
Return -1.

Step 3- If it holds false, then

popped out the value from the queue present at the front position
data = Queue[FRONT].
Return data.

Step 4- After then Set FRONT = FRONT + 1, it points next data element.

Algorithm of Peek operation

Step 1- Check if FRONT = REAR + 1.

Step 2- If the above statement holds, display the message; the queue is empty.

Step 3- If it holds false,

return the data element from the queue present at the front position.
data = Queue[FRONT].
Return data.

FIFO Approach implementation in C Programming language by queue using array

// C program to implement the FIFO Approach
// using queue by performing insertion and deletions operations in an array

#include<stdio.h>
#include<stdlib.h>
#define MAX 10             
int queue [ MAX ] ;            //Declaration of Array
int front = -1 , rear = -1 ;
void enqueue () ;
int dequeue () ;
int peek () ;
void display () ;

void main()
{
	int choice , data ;
	while ( 1 )
	{
		printf ( " \n \n ***************** Menu ******************** \n " ) ;
		printf ( " 1. Insert the element \n " ) ;
		printf ( " 2. Delete the element \n " ) ;
		printf ( " 3. Peek value on queue \n " ) ;
		printf ( " 4. Display Queue \n " ) ;
		printf ( " 5. Exit \n " ) ;
		printf ( " Enter your choice -> " ) ;
		scanf ( "%d" , &choice ) ;
		
		switch ( choice )
		{
			case 1 :
				enqueue () ;
				break ;
			case 2 :
				data = dequeue () ;
				if ( data != -1 )
				printf ( " \n The data element popped out from queue is -> %d " , data ) ;
				break ;
			case 3 :
				data = peek () ;
				if ( data != -1 )
				printf ( " \n The first value in queue is -> %d " , data ) ;
				break ;
			case 4 :
				display () ;
				break ;
			case 5 :
				exit ( 0 ) ;
				break ;
			default :
				printf ( " \n Choice not available \n " ) ;		
		}	
	}
}
void enqueue ()
{
	int val ;
	printf ( " Enter data to insert in queue -> " ) ;
	scanf ( "%d" , &val ) ;
	if ( rear == MAX - 1 )
	{
		printf ( " Overflow Condition " ) ;
	}
	else 
	{
	if ( front == -1 )
	{
		front = 0 ;
	}
	    rear = rear + 1 ;
		queue [ rear ] = val ;
		
	}
}
int dequeue ()
{
	int val ;
	if ( front == -1 || rear < front )
	{
		printf ( " \n Underflow condition " ) ;
		return -1 ;
	}
	else
	{
		val = queue [ front ] ;
		front = front + 1 ;
		if ( front > rear )
		{
			front = rear = -1 ;
		}
		return val ;
	}
}
int peek ()
{
	if ( front == -1 || rear < front )
	{
		printf ( " \n Queue is empty " ) ;
		return -1 ;
	}
	else
	{
		return queue [ front ] ;
	}	
}
void display()
{
	int i ;
	printf ( " \n " ) ;
	if ( front == -1 || front > rear )
	{
	printf ( " \n Queue is empty " ) ;
    }
	else
	{
		for ( i = front ; i <= rear ; i++ )
		{
			printf ( " %d \n " , queue [ i ] ) ;
		}
	}
}

The Output of the above program is:

FIFO Approach implementation in C++ Programming language by queue using Array

// C++ program to implement the FIFO Approach
// using queue by performing insertion and deletions operations in array

#include<iostream>
using namespace std;
#include<stdlib.h>
#define MAX 10             //changing this value will change the length of queue
int queue [ MAX ] ;            //Declaration of Array
int front = -1 , rear = -1 ;
void enqueue () ;
int dequeue () ;
int peek () ;
void display () ;

int main()
{
	int choice , data ;
	while ( 1 )
	{
		cout << endl ;
		cout << " ***************** Menu ******************** " << endl ;
		cout << " 1. Insert the element " << endl ;
		cout << " 2. Delete the element " << endl ;
		cout << " 3. Peek value on queue " << endl ;
		cout << " 4. Display Queue " << endl  ;
		cout << " 5. Exit " << endl ;
		cout << " Enter your choice -> " ;
		cin >> choice ;
		
		switch ( choice )
		{
			case 1 :
				enqueue () ;
				break ;
			case 2 :
				data = dequeue () ;
				if ( data != -1 )
				cout << " The data element popped out from queue is -> " << data << endl ;
				break ;
			case 3 :
				data = peek () ;
				if ( data != -1 )
				cout << " The first value in queue is -> " <<  data << endl ;
				break ;
			case 4 :
				display () ;
				break ;
			case 5 :
				exit ( 0 ) ;
				break ;
			default :
				cout << " Choice not available " << endl ;		
		}	
	}
}
void enqueue ()
{
	int val ;
	cout << " Enter data to insert in queue -> " ;
	cin >> val ;
	if ( rear == MAX - 1 )
	{
		cout << " Overflow Condition " << endl ;
	}
	else 
	{
	if ( front == -1 )
	{
		front = 0 ;
	}
	    rear = rear + 1 ;
		queue [ rear ] = val ;
		
	}
}
int dequeue ()
{
	int val ;
	if ( front == -1 || rear < front )
	{
		cout << " Underflow condition " << endl ;
		return -1 ;
	}
	else
	{
		val = queue [ front ] ;
		front = front + 1 ;
		if ( front > rear )
		{
			front = rear = -1 ;
		}
		return val ;
	}
}
int peek ()
{
	if ( front == -1 || rear < front )
	{
		cout << " Queue is empty " << endl ;
		return -1 ;
	}
	else
	{
		return queue [ front ] ;
	}	
}
void display()
{
	int i ;
	cout << endl ;
	if ( front == -1 || front > rear )
	{
	cout << " Queue is empty " << endl ;
    }
	else
	{
		for ( i = front ; i <= rear ; i++ )
		{
			cout << queue [ i ] << endl ;
		}
	}
}

The Output of the above program is:

FIFO Approach implementation in Java Programming language using queue

// Java program to implement the FIFO Approach
// using queue by performing insertion and deletions operations in an array

class Queue {
    private static int front, rear, cap;
    private static int queue[];
 
    Queue(int c)
    {
        front = rear = 0;
        cap = c;
        queue = new int[cap];
    }
 
    
    static void queueenq(int data)
    {
        // check queue is full or not
        if (cap == rear) {
            System.out.printf("\nQueue is full\n");
            return;
        }
 
        // insert element at the rear
        else {
            queue[rear] = data;
            rear++;
        }
        return;
    }
 
    // function to delete an element
    // from the front of the queue
    static void queuedeq()
    {
       
        if (front == rear) {
            System.out.printf("\nQueue is empty\n");
            return;
        }
        else {
            for (int i = 0; i < rear - 1; i++) {
                queue[i] = queue[i + 1];
            }  
            if (rear < capacity)
                queue[rear] = 0;           
            rear--;
        }
        return;
    }
    static void queuedisplay()
    {
        int i;
        if (front == rear) {
            System.out.printf("\nQueue is Empty\n");
            return;
        }
        for (i = front; i < rear; i++) {
            System.out.printf(" %d <-- ", queue[i]);
        }
        return;
    }
    static void queuefront()
    {
        if (front == rear) {
            System.out.printf("\nQueue is Empty\n");
            return;
        }
        System.out.printf("\nFront Element is: %d", queue[front]);
        return;
    }
}
public class SQueue {
    public static void main(String[] args)
    {
        Queue q = new Queue(4);
        // print Queue elements
        q.queuedisplay();
        // inserting elements in the queue
        q.queueenq(20);
        q.queueenq(30);
        q.queueenq(40);
        q.queueenq(50);
 
        // print Queue elements
        q.queuedisplay();
        // insert element in the queue
        q.queueenq(60);
        // print Queue elements
        q.queuedisplay();
        q.queuedeq();
        q.queuedeq();
        System.out.printf("\n\nafter two node deletion\n\n");
        q.queuedisplay();        
        q.queuefront();
    }
}

The Output of the above program is:

Queue is Empty
 20 <--  30 <--  40 <--  50 <-- 
Queue is full
 20 <--  30 <--  40 <--  50 <-- 

after two node deletion

 40 <--  50 <-- 
Front Element is: 40

FIFO Approach implementation in Python Programming language using queue

# Python program to implement the FIFO Approach
# using queue by performing insertion and deletions operations in an array
q = []
 

for i in range(5):
    q.append(i)
 

print("Elements of queue-" , q)
 

remove = q.pop(0)
print("removed element-" , remove)
 
print(q)
 
# To view the head of Queue
head = q[0]
print("head of the queue-", head)
 
size = len(q)
print("Size of queue-" , size)

The Output of the above program is:

   Elements of queue - [ 0, 1, 2, 3, 4 ]
   removed element - 0
   [ 1, 2, 3, 4 ]
   Peek value of queue - 1
   Size of queue - 4

FIFO Approach implementation in C# Programming language using queue

// C# program to implement the FIFO Approach
// using queue by performing insertion and deletions operations in an array

using System;
using System.Collections.Generic;
 
public class QueueImplement
{
    public static void Main(String[] args)
    {
        Queue<int> q = new Queue<int>();
 

        for (int i = 0; i < 5; i++)
            q.Enqueue(i);
 
        
        Console.Write("Elements of queue-");
        foreach(int s in q)
                Console.Write(s + " ");
 
        

        int remove = q.Dequeue();
        Console.Write("\nremoved element-" + remove + "\n");
        foreach(int s in q)
                Console.Write(s + " ");
 
       
        int head = q.Peek();
        Console.Write("\n Peek value of queue-" + head);
 
        

        int size = q.Count;
        Console.WriteLine("\nSize of queue-" + size);
    }
}

The Output of the above program is:

   Elements of queue - [ 0, 1, 2, 3, 4 ]
   removed element - 0
   [ 1, 2, 3, 4 ]
   Peek value of queue - 1
   Size of queue - 4

FIFO Approach implementation in JavaScript Programming language using queue

<script> 
// C# program to implement the FIFO Approach
// using queue by performing insertion and deletions operations in array
let q = [];

for (let i = 0; i < 5; i++)
    q.push(i);
 

document.write("Elements of queue-[" + q.join(", ")+"]<br>");
 

let remove = q.shift();
document.write("removed element-" + remove+"<br>");
 
document.write("["+q.join(", ")+"]<br>");
let head = q[0];
document.write("Peek value of queue-" + head+"<br>");
 

let size = q.length;
document.write("Size of queue-" + size+"<br>");

</script>

The Output of the above program is:

   Elements of queue - [ 0, 1, 2, 3, 4 ]
   removed element - 0
   [ 1, 2, 3, 4 ]
   Peek value of queue - 1
   Size of queue - 4

FIFO Approach implementation in C Programming language by queue using stack

// C program to implement the FIFO Approach
// using queue by performing push and pop operations in the stack

#include<stdio.h>
#include<stdlib.h>
#define N 5
int stack1 [ N ] , stack2 [ N ] ;
int top1 = -1 , top2 = -1 ;
void enq ( int ) ;
void dq ( ) ;
void push1 ( int ) ;
void push2 ( int ) ;
int pop1 ( ) ;
int pop2 ( ) ;
int count = 0 ;
void display ( ) ;

void enq ( int val )
{
	push1 ( val ) ;
	count = count  + 1 ;
}
void push2 ( int val )
{
		top2 = top2 + 1 ;
		stack2 [ top2 ] = val ;
}
void push1 ( int val )
{
	if ( top1 == N - 1 )
	{
		printf ( " Queue is full !! \n " ) ;
	}
	else
	{
		top1 = top1 + 1;
		stack1 [ top1 ] = val ;
	}
}
int pop1 ( )
{
	return stack1 [ top1-- ] ;
}
int pop2 ( )
{
	return stack2 [ top2 -- ] ;
}

void deq ( )
{
	if ( top1 == -1 && top2 == -1 )
	{
		printf ( "Queue is empty !! \n " ) ;
	}
	else
	{
		int i = 0 , b ;
		for ( i = 0 ; i < count ; i++ )
		{
			push2 ( pop1 ( ) ) ;
		}
		b = pop2 () ;
		count = count - 1 ;
		for ( i = 0 ; i < count ; i++ )
		{
			push1 ( pop2 () ) ;
		}
	}
}
void display()
{
	int i ;
	for ( i = 0 ; i <= top1 ; i++ )
	{
		printf ( " %d \n " , stack1 [ i ] ) ;
	}
}
void main()
{
	deq ( ) ;                         // queue is empty
	enq ( 10 ) ;
	enq ( 20 ) ;
	enq ( 30 ) ;
	enq ( 40 ) ;
	enq ( 50 ) ;
	enq ( 60 ) ;                            // queue is full
	deq ( ) ;
	display ( ) ;                            // 20 30 40 50
}

The Output of the above program is:

  Queue is empty !!
  Queue is full !!
  20
  30
  40
  50

FIFO Approach implementation in C++ Programming language by queue using stack

// C++ program to implement the FIFO Approach
// using queue by performing push and pop operations in stack
#include<iostream>
using namespace std;
#include<stdlib.h>
#define N 5
int stack1 [ N ] , stack2 [ N ] ;
int top1 = -1 , top2 = -1 ;
void enq ( int ) ;
void dq ( ) ;
void push1 ( int ) ;
void push2 ( int ) ;
int pop1 ( ) ;
int pop2 ( ) ;
int count = 0 ;
void display ( ) ;

void enq ( int val )
{
	push1 ( val ) ;
	count = count  + 1 ;
}
void push2 ( int val )
{
		top2 = top2 + 1 ;
		stack2 [ top2 ] = val ;
}
void push1 ( int val )
{
	if ( top1 == N - 1 )
	{
		cout << " Queue is full !! " << endl ;
	}
	else
	{
		top1 = top1 + 1;
		stack1 [ top1 ] = val ;
	}
}
int pop1 ( )
{
	return stack1 [ top1-- ] ;
}
int pop2 ( )
{
	return stack2 [ top2 -- ] ;
}

void deq ( )
{
	if ( top1 == -1 && top2 == -1 )
	{
		cout << "Queue is empty !! " << endl ;
	}
	else
	{
		int i = 0 , b ;
		for ( i = 0 ; i < count ; i++ )
		{
			push2 ( pop1 ( ) ) ;
		}
		b = pop2 () ;
		count = count - 1 ;
		for ( i = 0 ; i < count ; i++ )
		{
			push1 ( pop2 () ) ;
		}
	}
}
void display()
{
	int i ;
	for ( i = 0 ; i <= top1 ; i++ )
	{
		cout << stack1[ i ] << endl ;
	}
}
int  main()
{
	deq ( ) ;                         // queue is empty
	enq ( 7 ) ;
	enq ( 20 ) ;
	enq ( 3 ) ;
		display ( ) ;  
	enq ( 40 ) ;
	enq ( 50 ) ;
	                           // queue is full
	deq ( ) ;
	deq ( ) ;
	display ( ) ;                            // 20 30 40 50
}

The Output of the above program is:

Queue is empty !!
  Queue is full !!
  20
  3
  40
  50

Circular Queue

Implementation of FIFO Approach using a circular queue

A circular queue is also one of the important types of a queue. It is similar to the linear queue but has some variations. The end position of a circular queue is connected back to the start position, forming the circular-like structure and making a circle. A circular queue is also based on the First In First Out (FIFO) principle. It is also known as 'Ring Buffer'.

As we have seen previously, in a linear queue, further insertion of data elements is not possible when REAR reaches the end, and FRONT also reaches to end. The queue is still empty, but it shows that the queue is full, so to overcome the above problem concept of circular is introduced. In the circular queue, this problem will not arise. We will further discuss it in more detail in the below section.

The data structure, which is based on the FIFO principle, is a stack. We mainly perform two operations on it, push and pop. Push operation is used to push the data element into the stack, and pop operation is used to pop out the data elements from the stack.

There are certain basic operations has performed in the linear queue are as follows->

Enqueue
- This operation is used to insert a data element in the queue.
- A data element is always added from the rear position in a circular queue.
Dequeue
- This operation is used to remove a data element from the queue.
- In a circular queue, deletion of a data element is always done from the front position.

Two ends of Circular Queue

In a circular queue, there is a circle like structure; hence there are no two ends distinguished but still, to differentiate the insertion and deletion criteria of data elements, we refer to these two ends:

Front end- is used to delete the data elements from the queue.
The rear end is used to insert the data elements in the queue.

Implementation of Circular Queue using an array

A circular queue can easily be implemented using arrays. It works on the circular increment process. As stated earlier, it has two pointers, front and rear. From the rear end, insertion of data elements is possible. If the rear pointer reaches the end, it again increments back to the initial position of the queue so that further insertions can also be possible; hence this implies an increment process.

From the front end, deletion of data elements is possible. If the front pointer reaches the end, it returns to the queue's initial position to make further deletions possible.

Using modulo division with the queue size, the circular increment is performed.

Steps

Initially, we need to create an array of size 'n' whether statically or dynamically, depending on the user.
Then declare two pointers named FRONT and REAR.
Initialize REAR = -1 and FRONT = -1.
Create two functions named Enqueue for adding data elements in the Queue and Dequeue for deleting data elements from the queue.

Implementation of Circular Queue

Algorithm of Enqueue operation

Step 1- Check if FRONT == 0 && REAR == (n-1) || REAR == (FRONT - 1) % (n-1).

Step 2- If the above statement holds, then such condition is said to be an Overflow, and further insertion of data elements is not possible.

Step 3- Else if FRONT == -1 then,

set REAR = 0, FRONT = 0 and
Add the data element in queue at rear position.
Queue[REAR] = data.

Step 4- Else if REAR == (n-1) && FRONT != 0

set REAR = 0 and
Add the data element in queue at rear position.
Queue[REAR] = data.

Step 5- Else

set REAR = REAR + 1
Add the data element in queue at rear position.
Queue[REAR] = data.

Algorithm of Dequeue operation

Step 1- Check if FRONT == -1

Step 2- If the above statement holds, then

such condition is said to be an Underflow condition.
Return -1.

Step 3- If it holds false, then

popped out value from the queue present at the front position
data = Queue[FRONT].
Return data.

Step 4- After then Set FRONT = FRONT + 1, it points next data element.

Step 5- If FRONT == REAR then, set FRONT = -1 and REAR = -1.

Step 6- Else if FRONT == n-1 then, set FRONT = 0.

FIFO Approach implementation in C Programming language by Circular queue

// C program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations
#include<stdio.h>
#include<stdlib.h>
struct queue {
	int size ;
	int f , r ;
	int *arr ;
} ;
int isempty ( struct queue *q )
{
	if ( q -> f == q -> r )
	{ return 1 ;
	}
	return 0 ;
}

int isfull ( struct queue *q )
{
	if ( q -> r == ( q -> size ) - 1 )
	{
		return 1 ;
}
else
return 0 ;	
}
int dequeue ( struct queue *q )
{
	int a = - 1 ;
	if ( isempty ( q ) )
	{
		printf ( "Queue is Empty !! \n " ) ;
	}
	else
	{
		q -> f = q -> f + 1 ;
		a = q -> arr [ q -> f ] ;
	}
	return a ;
}
void enqueue ( struct queue *q , int val )
{
	if ( isfull ( q ) )
	{
		printf ( "Queue is full !! \n " ) ;
	}
	else
	{
		q -> r = q -> r + 1 ;
		q -> arr [ q -> r ] = val ;
		printf ( "Enqueue value %d successfully !! \n \n " , val ) ;
	}
}
int main()
{
	struct queue q ;
//	q = malloc ( sizeof ( struct queue ) ) ;
	q.size = 5 ;

	q.arr = ( int * ) malloc ( sizeof ( int ) * q.size ) ;
	q.f = q.r = - 1 ;
//  enqueue opration
    enqueue ( &q , 20 ) ;
    enqueue ( &q , 30 ) ;
    enqueue ( &q , 40 ) ;
    enqueue ( &q , 60 ) ;
    enqueue ( &q , 70 ) ;
    enqueue ( &q , 19 ) ;
// Dequeue operation
    printf ( "Deleting  value: %d \n \n " , dequeue( &q ) ) ;
    printf ( "Deleting  value: %d \n \n " , dequeue( &q ) ) ;
    printf ( "Deleting  value: %d \n \n " , dequeue( &q ) ) ;
    printf ( "Deleting  value: %d \n \n " , dequeue( &q ) ) ;
    dequeue ( &q ) ;

	return 0 ;
}

The Output of the above program is:

 Enqueue value 20 successfully !!
 Enqueue value 30 successfully !!
 Enqueue value 40 successfully !!
 Enqueue value 60 successfully !!
 Enqueue value 70 successfully !!
 Queue is full !!
 Deleting  value: 20
 Deleting  value: 30
 Deleting  value: 40
 Deleting  value: 60

FIFO Approach implementation in C++ Programming language by Circular queue using Structure

// C++ program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations
#include<iostream>
using namespace std;
#include<stdlib.h>
struct queue {
	int size ;
	int f , r ;
	int *arr ;
} ;
int isempty ( struct queue *q )
{
	if ( q -> f == q -> r )
	{ return 1 ;
	}
	return 0 ;
}

int isfull ( struct queue *q )
{
	if ( q -> r == ( q -> size ) - 1 )
	{
		return 1 ;
}
else
return 0 ;	
}
int dequeue ( struct queue *q )
{
	int a = - 1 ;
	if ( isempty ( q ) )
	{
		cout << "Queue is Empty !! " << endl ;
	}
	else
	{
		q -> f = q -> f + 1 ;
		a = q -> arr [ q -> f ] ;
	}
	return a ;
}
void enqueue ( struct queue *q , int val )
{
	if ( isfull ( q ) )
	{
		cout << "Queue is full !! " << endl ;
	}
	else
	{
		q -> r = q -> r + 1 ;
		q -> arr [ q -> r ] = val ;
		cout << "Enqueue value " << val << " successfully !! " << endl << endl ;
	}
}
int main()
{
	struct queue q ;
//	q = malloc ( sizeof ( struct queue ) ) ;
	q.size = 5 ;

	q.arr = ( int * ) malloc ( sizeof ( int ) * q.size ) ;
	q.f = q.r = - 1 ;
//  enqueue opration
    enqueue ( &q , 7 ) ;
    enqueue ( &q , 11 ) ;
    enqueue ( &q , 4 ) ;
    enqueue ( &q , 6 ) ;
    enqueue ( &q , 7 ) ;
    enqueue ( &q , 19 ) ;
// Dequeue operation
    cout << "Deleting  value: " << dequeue( &q ) << endl ;
    cout << "Deleting  value: " << dequeue( &q ) << endl ;
    cout << "Deleting  value: " << dequeue( &q ) << endl ;
    cout << "Deleting  value: " << dequeue( &q ) << endl ;
    dequeue ( &q ) ;

	return 0 ;
}

The Output of the above program is:

Enqueue value 7 successfully !!
 Enqueue value 11 successfully !!
 Enqueue value 4 successfully !!
 Enqueue value 6 successfully !!
 Enqueue value 7 successfully !!
 Queue is full !!
 Deleting  value: 7
 Deleting  value: 11
 Deleting  value: 4
 Deleting  value: 6

FIFO Approach implementation in Java Programming language by Circular Queue using Array

// Java program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations import java.util.ArrayList;
 
class Circularqueue{
 
private int size, front, rear;
 
private ArrayList<Integer> queue = new ArrayList<Integer>();
 
Circularqueue(int size)
{
    this.size = size;
    this.front = this.rear = -1;
}
 
public void enqueue(int data)
{
     
    
    if((front == 0 && rear == size - 1) ||
      (rear == (front - 1) % (size - 1)))
    {
        System.out.print("Queue is Full !!");
    }
 
    else if(front == -1)
    {
        front = 0;
        rear = 0;
        queue.add(rear, data);
    }
 
    else if(rear == size - 1 && front != 0)
    {
        rear = 0;
        queue.set(rear, data);
    }
 
    else
    {
        rear = (rear + 1);
     
        if(front <= rear)
        {
            queue.add(rear, data);
        }
     
      
        else
        {
            queue.set(rear, data);
        }
    }
}
 
public int dequeue()
{
    int temp;
 
    if(front == -1)
    {
        System.out.print("Queue is Empty");
         
        return -1;
    }
 
    temp = queue.get(front);
 
    
    if(front == rear)
    {
        front = -1;
        rear = -1;
    }
 
    else if(front == size - 1)
    {
        front = 0;
    }
    else
    {
        front = front + 1;
    }
     

    return temp;
}
public void displayqueue()
{
     
    
    if(front == -1)
    {
        System.out.print("Queue is Empty");
        return;
    }
 
    System.out.print("Elements in the " +
                     "circular queue are: ");
 
    if(rear >= front)
    {
     
        for(int i = front; i <= rear; i++)
        {
            System.out.print(queue.get(i));
            System.out.print(" ");
        }
        System.out.println();
    }
 
    
    else
    {
         
        for(int i = front; i < size; i++)
        {
            System.out.print(queue.get(i));
            System.out.print(" ");
        }
 
        for(int i = 0; i <= rear; i++)
        {
            System.out.print(queue.get(i));
            System.out.print(" ");
        }
        System.out.println();
    }
}
 

public static void main(String[] args)
{
     
    Circularqueue q = new Circularqueue(5);
     
    q.enqueue(14);
    q.enqueue(22);
    q.enqueue(13);
    q.enqueue(8);
     
    q.displayqueue();
 
    int del = q.dequeue();
 
        if(del != -1)
    {
        System.out.print("Deleted value = ");
        System.out.println(del);
    }
 
    del = q.dequeue();
 
        if(del != -1)
    {
        System.out.print("Deleted value = ");
        System.out.println(del);
    }
 
    q.displayqueue();
     
    q.enqueue(9);
    q.enqueue(20);
    q.enqueue(5);
     
    q.displayqueue();
     
    q.enqueue(20);
}
}

The Output of the above program is:

Elements in Circular Queue are : 14   22  13   8
Deleted value = 14    
Deleted value = 22    
Elements in Circular Queue are : 13  8
Elements in Circular Queue are :  13  8   9   20   5
Queue is Full !!

FIFO Approach implementation in Python Programming language by Circular queue using Array

# Python program to implement the FIFO Approach
# using circular queue by performing insertion and deletion operations
class Circularqueue():
 
    
    def __init__(self, size): # initializing the class
        self.size = size
         
        self.queue = [None for i in range(size)]
        self.front = self.rear = -1
 
    def enqueue(self, data):
         
        if ((self.rear + 1) % self.size == self.front):
            print(" Queue is Full !! \n")
             
            elif (self.front == -1):
            self.front = 0
            self.rear = 0
            self.queue[self.rear] = data
        else:
             
            self.rear = (self.rear + 1) % self.size
            self.queue[self.rear] = data
             
    def dequeue(self):
        if (self.front == -1): # condition for empty queue
            print ("Queue is Empty\n")
             
            elif (self.front == self.rear):
            temp=self.queue[self.front]
            self.front = -1
            self.rear = -1
            return temp
        else:
            temp = self.queue[self.front]
            self.front = (self.front + 1) % self.size
            return temp
 
    def display(self):
     
        
        if(self.front == -1):
            print ("Queue is Empty")
 
        elif (self.rear >= self.front):
            print("Elements in the circular queue are:",
                                              end = " ")
            for i in range(self.front, self.rear + 1):
                print(self.queue[i], end = " ")
            print ()
 
        else:
            print ("Elements in Circular Queue are:",
                                           end = " ")
            for i in range(self.front, self.size):
                print(self.queue[i], end = " ")
            for i in range(0, self.rear + 1):
                print(self.queue[i], end = " ")
            print ()
 
        if ((self.rear + 1) % self.size == self.front):
            print("Queue is Full")
 

q = Circularqueue(5)
q.enqueue(4)
q.enqueue(22)
q.enqueue(3)
q.enqueue(-6)
q.display()
print ("Deleted value = ", q.dequeue())
print ("Deleted value = ", q.dequeue())
q.display()
q.enqueue(19)
q.enqueue(2)
q.enqueue(15)
q.display()

The Output of the above program is:

Elements in Circular Queue are : 4   22   3   -6
Deleted value = 4    
Deleted value = 22    
Elements in Circular Queue are : 3  -6
Elements in Circular Queue are :  3  -6   19   2   15
Queue is Full !!

FIFO Approach implementation in C Programming language by Circular Queue using Linked List

// C program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations
#include<stdio.h>
#include<stdlib.h>
struct cqueue
{
	int size ;
	int f , r ;
	int *array ;
} ;
int isfull ( struct cqueue *q )
{
	if ( (q -> r + 1 ) % q -> size == q -> f )
	return 1 ;
	else
	return 0 ;
}
int isempty ( struct cqueue *q )
{
	if ( q -> f == q -> r )
	{
		return 1 ;
	}
	else
	return 0 ;
}
void enqueue ( struct cqueue  *q , int val )
{
	if ( isfull ( q ) )
	{
		printf ( " Queue is full !! \n " ) ;
	}
	else
	{
		q -> r = ( q -> r + 1 ) % q -> size ;
		q -> array [ q -> r ] = val ;
		printf ( "Enqueue value is: %d \n " , val ) ;
	}
}
int dequeue ( struct cqueue *q )
{
	int a = - 1 ;
	if ( isempty ( q ) )
	{
		printf ( "Queue is empty !! \n " ) ;
	}
	else
	{
		q -> f = ( q -> f + 1 ) % q -> size ;
		a = q -> array [ q -> f ] ;
		
	}
	return a ;
}
int main()
{
	struct cqueue q ;
	q.size = 4 ;
	q.f = q.r = 0 ;
	q.array = ( int *) malloc ( sizeof ( int ) * q.size ) ;
//  enqueue opration
	enqueue ( &q , 20 ) ;
	enqueue ( &q , 30 ) ;
	enqueue ( &q , 40 ) ;
//	enqueue ( &q , 50 ) ;
//Dequeue operation
    printf ( "Deleting  value: %d \n \n " , dequeue ( &q ) ) ;
    printf ( "Deleting  value: %d \n \n " , dequeue ( &q ) ) ;
    printf ( "Deleting  value: %d \n \n " , dequeue ( &q ) ) ;
 //   printf ( dequeue ( &q ) ) ;
	if ( isempty ( &q ) )
	{
		printf ( "Queue is empty !! \n " ) ;
	}	
	enqueue ( &q , 60 ) ;
	enqueue ( &q , 50 ) ;
	enqueue ( &q , 70 ) ;
	enqueue ( &q , 90 ) ;
	
}

The Output of the above program is:

Enqueue value is: 20
 Enqueue value is: 30
 Enqueue value is: 40
 Deleting  value: 20
 Deleting  value: 30
 Deleting  value: 40
 Queue is empty !!
 Enqueue value is: 60
 Enqueue value is: 50
 Enqueue value is: 70
  Queue is full !!

FIFO Approach implementation in C++ Programming language by Circular queue using Linked List

// C++ program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations
#include<iostream>
using namespace std ;
#include<stdlib.h>
struct cqueue
{
	int size ;
	int f , r ;
	int *array ;
} ;
int isfull ( struct cqueue *q )
{
	if ( (q -> r + 1 ) % q -> size == q -> f )
	return 1 ;
	else
	return 0 ;
}
int isempty ( struct cqueue *q )
{
	if ( q -> f == q -> r )
	{
		return 1 ;
	}
	else
	return 0 ;
}
void enqueue ( struct cqueue  *q , int val )
{
	if ( isfull ( q ) )
	{
		cout << " Queue is full !! " << endl ;
	}
	else
	{
		q -> r = ( q -> r + 1 ) % q -> size ;
		q -> array [ q -> r ] = val ;
		cout << "Enqueue value is: " << val << endl ;
	}
}
int dequeue ( struct cqueue *q )
{
	int a = - 1 ;
	if ( isempty ( q ) )
	{
		cout << "Queue is empty " << endl ;
	}
	else
	{
		q -> f = ( q -> f + 1 ) % q -> size ;
		a = q -> array [ q -> f ] ;
		
	}
	return a ;
}
int main()
{
	struct cqueue q ;
	q.size = 4 ;
	q.f = q.r = 0 ;
	q.array = ( int *) malloc ( sizeof ( int ) * q.size ) ;
//  enqueue opration
	enqueue ( &q , 20 ) ;
	enqueue ( &q , 30 ) ;
	enqueue ( &q , 40 ) ;
//	enqueue ( &q , 50 ) ;
//Dequeue operation
    cout << "Deleting  value: " << dequeue ( &q ) << endl ;
    cout << "Deleting  value: " << dequeue ( &q ) << endl ;
    cout << "Deleting  value: " << dequeue ( &q ) << endl ;
 //   printf ( dequeue ( &q ) ) ;
	if ( isempty ( &q ) )
	{
		cout << "Queue is empty !! " << endl ;
	}	
	enqueue ( &q , 60 ) ;
	enqueue ( &q , 50 ) ;
	enqueue ( &q , 70 ) ;
	enqueue ( &q , 90 ) ;
	
}

The Output of the above program is:

Enqueue value is: 20
 Enqueue value is: 30
 Enqueue value is: 40
 Deleting  value: 20
 Deleting  value: 30
 Deleting  value: 40
 Queue is empty !!
 Enqueue value is: 60
 Enqueue value is: 50
 Enqueue value is: 70
  Queue is full !!

FIFO Approach implementation in Java Programming language by Circular Queue using Linked List

// Java program to implement the FIFO Approach
// using circular queue by performing insertion and deletion operations
import java.util.*;
  
class Solution {
  
    // Structure of a Node
    static class Node {
        int data;
        Node next;
    }
  
    static class Queue {
        Node front, rear;
    }
  
    // Function to create Circular queue
    static void enqueue(Queue q, int value)
    {
        Node temp = new Node();
        temp.data = value;
        if (q.front == null)
            q.front = temp;
        else
            q.rear.next = temp;
  
        q.rear = temp;
        q.rear.next = q.front;
    }
  
   
    static int dequeue(Queue q)
    {
        if (q.front == null) {
            System.out.printf("Queue is empty");
            return Integer.MIN_VALUE;
        }
  
       
        int value; 
        if (q.front == q.rear) {
            value = q.front.data;
            q.front = null;
            q.rear = null;
        }
        else // There are more than one nodes
        {
            Node temp = q.front;
            value = temp.data;
            q.front = q.front.next;
            q.rear.next = q.front;
        }
  
        return value;
    }
  
    
    static void displayqueue(Queue q)
    {
        Node temp = q.front;
        System.out.printf("\nElements in Circular Queue are: ");
        while (temp.next != q.front) {
            System.out.printf("%d ", temp.data);
            temp = temp.next;
        }
        System.out.printf("%d", temp.data);
    }
  
    public static void main(String args[])
    {
        
        Queue q = new Queue();
        q.front = q.rear = null;
  
        
        enqueue(q, 10);
        enqueue(q, 2);
        enqueue(q, 16);
  
        
        displayqueue(q);
  
        
        System.out.printf("\nDeleted value = %d", dequeue(q));
        System.out.printf("\nDeleted value = %d", dequeue(q));
  
        
        displayqueue(q);
  
        enqueue(q, 19);
        enqueue(q, 7);
        displayqueue(q);
    }
}

The Output of the above program is:

Elements in Circular Queue are : 10   2    16
Deleted value = 10    
Deleted value = 2    
Elements in Circular Queue are : 16
Elements in Circular Queue are : 16    19   7

FIFO Approach implementation in Python Programming language by Circular Queue using Linked List

# Python program to implement the FIFO Approach
# using circular queue by performing insertion and deletion operations
  
# Structure of a Node 
class Node:
    def __init__(self):
        self.data = None
        self.next = None
  
class Queue:
    def __init__(self):
        front = None
        rear = None
  
# Function to create Circular queue 
def enqueue(q, value):
    temp = Node() 
    temp.data = value 
    if (q.front == None): 
        q.front = temp 
    else:
        q.rear.next = temp 
  
    q.rear = temp 
    q.rear.next = q.front
  
# Function to delete element from 
# Circular Queue 
def dequeue(q):
    if (q.front == None):
        print("Queue is empty") 
        return -1
  
    
    value = None                          # Value to be dequeued 
    if (q.front == q.rear):
        value = q.front.data
        q.front = None
        q.rear = None
    else: # There are more than one nodes 
        temp = q.front 
        value = temp.data 
        q.front = q.front.next 
        q.rear.next = q.front
  
    return value 
  
# Function displaying the elements 
# of Circular Queue 
def displayqueue(q):
    temp = q.front 
    print("Elements in Circular Queue are: ", 
                                   end = " ") 
    while (temp.next != q.front):
        print(temp.data, end = " ") 
        temp = temp.next
    print(temp.data)
  
if __name__ == '__main__':
  
    # Create a queue and initialize
    # front and rear 
    q = Queue() 
    q.front = q.rear = None
  
    # Inserting elements in Circular Queue 
    enqueue(q, 10) 
    enqueue(q, 2) 
    enqueue(q, 16) 
  
    # Display elements present in 
    # Circular Queue 
    displayqueue(q) 
  
    # Deleting elements from Circular Queue 
    print("Deleted value = ", dequeue(q)) 
    print("Deleted value = ", dequeue(q)) 
  
    # Remaining elements in Circular Queue 
    displayqueue(q) 
  
    enqueue(q, 19) 
    enqueue(q, 7) 
    displayqueue(q)

The Output of the above program is:

Elements in Circular Queue are : 10   2    16
Deleted value = 10    
Deleted value = 2    
Elements in Circular Queue are : 16
Elements in Circular Queue are : 16    19   7

Advantages of Circular Queue over Linear queue

Linear Queue consumes more memory as compared to circular queue.
A circular queue uses an efficient way for memory utilization.
In a circular queue, new data can be inserted again at a particular position after deleting previous data on that position.
In a linear queue, if the rear pointer reaches last and the front pointer deletes all data from the queue, it remains to show the message of Overflow, which is the main drawback of the linear queue.
An overflow message is shown in a circular queue when the queue is full.
Easy to perform dequeue operation and enqueue operation.

Next TopicWhat are connected graphs in data structure

← prev next →