How to manage Full Circular Queue event?
Last Updated :
21 Feb, 2023
What is a circular Queue?
A circular queue is a non-primitive, linear data structure. It is an extended version of a linear queue. It is also called a Circular buffer or cyclic buffer. It offers a quick and clean way of storing First First Out (FIFO) data with a maximum size.
Mainly it is used in memory management, process scheduling, and traffic systems, and also o good for serial data stream operation in Embedded systems.
Operations on Circular Queue:
- Front: Get the front item from the queue.
- Rear: Get the last item from the queue.
- enQueue(value) This function is used to insert an element into the circular queue. In a circular queue, the new element is always inserted at the Rear position.
- Check whether queue is Full – Check ((rear == SIZE-1 && front == 0) || (rear == front-1)).
- If it is full then display Queue is full. If the queue is not full then, check if (rear == SIZE – 1 && front != 0) if it is true then set rear=0 and insert the element.
- deQueue() This function is used to delete an element from the circular queue. In a circular queue, the element is always deleted from the front position.
- Check whether the queue is Empty means check (front==-1).
- If it is empty then display Queue is empty. If the queue is not empty then step 3
- Check if (front==rear) if it is true then set front=rear= -1 else check if (front==size-1), if it is true then set front=0 and return the element.
Full Circular Event (Overflow):
In a circular queue, when the queue becomes full it will start overwriting the inputs from the beginning of the queue.
Initially, when such a queue is empty, the “front” and the “rear” values are 0 & -1 respectively; and the queue has a NULL value for its entire element.
Every time we add an element to the queue, the “rear” value increments by 1 until it reaches the queue’s upper limit; after which it starts over again from 0. Similarly, every time we delete an element from the queue, the “front” value increments by 1 until it reaches the queue’s upper limit; after which it starts over again from 0.
Managing Full Circular Queue
- First initialize the queue, the size of the queue (i.e. MaxSize), and front & rear pointers.
- Enqueue:
- Check if the no. of elements is equal to the max size of the queue.
- If true, Print “Queue is full”
- If false, increment the rear pointer by 1.
- Dequeue:
- Check if the no. of elements is equal to zero
- If true, Print “Queue is empty”.
- If false, increment the front position by 1.
- Size:
- If rear ≥ front then, size = rear – front.
- If front > rear then, size = MaxSize – (front – rear).
Pseudo Codes:
Enqueue operation:
void enqueue(Queue q, int x)
{
if((rear+1)%maxsize)==front)
{
printf(“overflow”);
break;
}
else if(rear!=-1)
{
rear=(rear+1)%maxsize;
q[rear]=x;
}
}
Dequeue operation:
void dequeue(Queue q)
{
if(front!=-1)
printf(“underflow”);
else
front=(front+1)%maxsize;
}
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
class Queue {
int rear, front;
int size;
int * arr;
public :
Queue( int s)
{
front = rear = -1;
size = s;
arr = new int [s];
}
void enQueue( int value);
int deQueue();
void displayQueue();
};
void Queue::enQueue( int value)
{
if ((front == 0 && rear == size - 1)
|| (rear == (front - 1) % (size - 1))) {
printf ( "\nQueue is Full" );
return ;
}
else if (front == -1) {
front = rear = 0;
arr[rear] = value;
}
else if (rear == size - 1 && front != 0) {
rear = 0;
arr[rear] = value;
}
else {
rear++;
arr[rear] = value;
}
}
int Queue::deQueue()
{
if (front == -1) {
printf ( "\nQueue is Empty" );
return INT_MIN;
}
int data = arr[front];
arr[front] = -1;
if (front == rear) {
front = -1;
rear = -1;
}
else if (front == size - 1)
front = 0;
else
front++;
return data;
}
void Queue::displayQueue()
{
if (front == -1) {
printf ( "\nQueue is Empty" );
return ;
}
printf ( "\nElements in Circular Queue are: " );
if (rear >= front) {
for ( int i = front; i <= rear; i++)
printf ( "%d " , arr[i]);
}
else {
for ( int i = front; i < size; i++)
printf ( "%d " , arr[i]);
for ( int i = 0; i <= rear; i++)
printf ( "%d " , arr[i]);
}
}
int main()
{
Queue q(5);
q.enQueue(14);
q.enQueue(22);
q.enQueue(13);
q.enQueue(-6);
q.displayQueue();
printf ( "\nDeleted value = %d" , q.deQueue());
printf ( "\nDeleted value = %d" , q.deQueue());
q.displayQueue();
q.enQueue(9);
q.enQueue(20);
q.enQueue(5);
q.displayQueue();
q.enQueue(20);
return 0;
}
|
Java
import java.io.*;
class Queue {
int rear, front;
int size;
int [] arr;
Queue( int s)
{
front = rear = - 1 ;
size = s;
arr = new int [s];
}
void enQueue( int value)
{
if ((front == 0 && rear == size - 1 )
|| (rear == (front - 1 ) % (size - 1 ))) {
System.out.println( "Queue is Full" );
return ;
}
else if (front == - 1 ) {
front = rear = 0 ;
arr[rear] = value;
}
else if (rear == size - 1 && front != 0 ) {
rear = 0 ;
arr[rear] = value;
}
else {
rear++;
arr[rear] = value;
}
}
int deQueue()
{
if (front == - 1 ) {
System.out.println( "Queue is Empty" );
return Integer.MIN_VALUE;
}
int data = arr[front];
arr[front] = - 1 ;
if (front == rear) {
front = - 1 ;
rear = - 1 ;
}
else if (front == size - 1 ) {
front = 0 ;
}
else {
front++;
}
return data;
}
void displayQueue()
{
if (front == - 1 ) {
System.out.println( "Queue is Empty" );
return ;
}
System.out.print(
"Elements in Circular Queue are: " );
if (rear >= front) {
for ( int i = front; i <= rear; i++) {
System.out.print(arr[i] + " " );
}
}
else {
for ( int i = front; i < size; i++) {
System.out.print(arr[i] + " " );
}
for ( int i = 0 ; i <= rear; i++) {
System.out.print(arr[i] + " " );
}
}
System.out.println();
}
}
class GFG {
public static void main(String[] args)
{
Queue q = new Queue( 5 );
q.enQueue( 14 );
q.enQueue( 22 );
q.enQueue( 13 );
q.enQueue(- 6 );
q.displayQueue();
System.out.println( "Deleted value = "
+ q.deQueue());
System.out.println( "Deleted value = "
+ q.deQueue());
q.displayQueue();
q.enQueue( 9 );
q.enQueue( 20 );
q.enQueue( 5 );
q.displayQueue();
q.enQueue( 20 );
}
}
|
Python3
class Queue:
def __init__( self , s):
self .front = self .rear = - 1
self .size = s
self .arr = [ None ] * s
def enQueue( self , value):
if ( self .front = = 0 and self .rear = = self .size - 1 ) or ( self .rear = = ( self .front - 1 ) % ( self .size - 1 )):
print ( "\nQueue is Full" )
return
elif self .front = = - 1 :
self .front = self .rear = 0
self .arr[ self .rear] = value
elif self .rear = = self .size - 1 and self .front ! = 0 :
self .rear = 0
self .arr[ self .rear] = value
else :
self .rear + = 1
self .arr[ self .rear] = value
def deQueue( self ):
if self .front = = - 1 :
print ( "\nQueue is Empty" )
return float ( "-inf" )
data = self .arr[ self .front]
self .arr[ self .front] = None
if self .front = = self .rear:
self .front = - 1
self .rear = - 1
elif self .front = = self .size - 1 :
self .front = 0
else :
self .front + = 1
return data
def displayQueue( self ):
if self .front = = - 1 :
print ( "\nQueue is Empty" )
return
print ( "\nElements in Circular Queue are: " )
if self .rear > = self .front:
for i in range ( self .front, self .rear + 1 ):
print ( self .arr[i], end = " " )
else :
for i in range ( self .front, self .size):
print ( self .arr[i], end = " " )
for i in range ( 0 , self .rear + 1 ):
print ( self .arr[i], end = " " )
q = Queue( 5 )
q.enQueue( 14 )
q.enQueue( 22 )
q.enQueue( 13 )
q.enQueue( - 6 )
q.displayQueue()
print ( "\nDeleted value = " , q.deQueue())
print ( "\nDeleted value = " , q.deQueue())
q.displayQueue()
q.enQueue( 9 )
q.enQueue( 20 )
q.enQueue( 5 )
q.displayQueue()
q.enQueue( 20 )
|
C#
using System;
class Queue {
public int rear, front;
public int size;
public int [] arr;
public Queue( int s)
{
front = rear = -1;
size = s;
arr = new int [s];
}
public void enQueue( int value)
{
if ((front == 0 && rear == size - 1)
|| (rear == (front - 1) % (size - 1))) {
Console.WriteLine( "Queue is Full" );
return ;
}
else if (front == -1) {
front = rear = 0;
arr[rear] = value;
}
else if (rear == size - 1 && front != 0) {
rear = 0;
arr[rear] = value;
}
else {
rear++;
arr[rear] = value;
}
}
public int deQueue()
{
if (front == -1) {
Console.WriteLine( "Queue is Empty" );
return Int32.MinValue;
}
int data = arr[front];
arr[front] = -1;
if (front == rear) {
front = -1;
rear = -1;
}
else if (front == size - 1) {
front = 0;
}
else {
front++;
}
return data;
}
public void displayQueue()
{
if (front == -1) {
Console.WriteLine( "Queue is Empty" );
return ;
}
Console.Write( "Elements in Circular Queue are: " );
if (rear >= front) {
for ( int i = front; i <= rear; i++) {
Console.Write(arr[i] + " " );
}
}
else {
for ( int i = front; i < size; i++) {
Console.Write(arr[i] + " " );
}
for ( int i = 0; i <= rear; i++) {
Console.Write(arr[i] + " " );
}
}
Console.WriteLine();
}
}
public class GFG {
static public void Main()
{
Queue q = new Queue(5);
q.enQueue(14);
q.enQueue(22);
q.enQueue(13);
q.enQueue(-6);
q.displayQueue();
Console.WriteLine( "Deleted value = " + q.deQueue());
Console.WriteLine( "Deleted value = " + q.deQueue());
q.displayQueue();
q.enQueue(9);
q.enQueue(20);
q.enQueue(5);
q.displayQueue();
q.enQueue(20);
}
}
|
Javascript
class Queue {
constructor(s) {
this .front = this .rear = -1;
this .size = s;
this .arr = new Array(s);
}
enQueue(value) {
if (( this .front === 0 && this .rear === this .size - 1) || ( this .rear === ( this .front - 1) % ( this .size - 1))) {
console.log( "\nQueue is Full" );
return ;
}
else if ( this .front === -1) {
this .front = this .rear = 0;
this .arr[ this .rear] = value;
}
else if ( this .rear === this .size - 1 && this .front !== 0) {
this .rear = 0;
this .arr[ this .rear] = value;
}
else {
this .rear++;
this .arr[ this .rear] = value;
}
}
deQueue() {
if ( this .front === -1) {
console.log( "\nQueue is Empty" );
return Number.MIN_SAFE_INTEGER;
}
let data = this .arr[ this .front];
this .arr[ this .front] = -1;
if ( this .front === this .rear) {
this .front = -1;
this .rear = -1;
}
else if ( this .front === this .size - 1) {
this .front = 0;
}
else {
this .front++;
}
return data;
}
displayQueue() {
if ( this .front === -1) {
console.log( "\nQueue is Empty" );
return ;
}
console.log( "\nElements in Circular Queue are: " );
if ( this .rear >= this .front) {
for (let i = this .front; i <= this .rear; i++) {
console.log( this .arr[i] + " " );
}
}
else {
for (let i = this .front; i < this .size; i++) {
console.log( this .arr[i] + " " );
}
for (let i = 0; i <= this .rear; i++) {
console.log( this .arr[i] + " " );
}
}
}
}
let q = new Queue(5);
q.enQueue(14);
q.enQueue(22);
q.enQueue(13);
q.enQueue(-6);
q.displayQueue();
console.log( "Deleted value = " + q.deQueue());
console.log( "Deleted value = " + q.deQueue());
q.displayQueue();
q.enQueue(9);
q.enQueue(20);
q.enQueue(5);
q.displayQueue();
q.enQueue(20);
|
Output
Elements in Circular Queue are: 14 22 13 -6
Deleted value = 14
Deleted value = 22
Elements in Circular Queue are: 13 -6
Elements in Circular Queue are: 13 -6 9 20 5
Queue is Full
Time Complexity: Time complexity of enQueue(), deQueue() operation is O(1) as there is no loop in any of the operation.
Auxiliary Space: O(N) where N is the maximum possible size of the queue.
When to use full circular queue?
A full circular queue is used in situations where a traditional linear queue is not suitable. The main advantage of a circular queue over a linear queue is that it allows for more efficient memory usage in certain cases.
Here are some common scenarios where a full circular queue is used:
- Real-time Systems: In real-time systems, such as embedded systems, a full circular queue can be used to buffer data that is generated at a high rate and processed at a slower rate. This helps to ensure that no data is lost and the system runs smoothly.
- Audio/Video Streaming: In audio and video streaming, a full circular queue can be used to buffer incoming data so that it can be played smoothly even if there are interruptions in the data flow.
- Networking: In networking, a full circular queue can be used to buffer incoming data packets so that they can be processed in a timely manner, even if the processing rate is slower than the incoming data rate.
- Batch Processing: In batch processing, a full circular queue can be used to store the items that need to be processed in a batch. Once the queue is full, the batch processing can be triggered to process all the items in the queue in one go.
Related Articles:
Share your thoughts in the comments
Please Login to comment...