Implement a deque Using a circular array:
Deque or Double Ended Queue is a generalized version of the Queue data structure that allows insert and delete at both ends
Operations on Deque:
Mainly the following four basic operations are performed on queue:
- insertFront(): Adds an item at the front of Deque.
- insertRear(): Adds an item at the rear of Deque.
- deleteFront(): Deletes an item from front of Deque.
- deleteRear(): Deletes an item from rear of Deque.
In addition to above operations, following operations are also supported
- getFront(): Gets the front item from queue.
- getRear(): Gets the last item from queue.
- isEmpty(): Checks whether Deque is empty or not.
- isFull(): Checks whether Deque is full or not.
Circular array implementation of Deque:
For implementing deque, we need to keep track of two indices, front, and rear. We enqueue(push) an item at the rear or the front end of the dequeue and dequeue(pop) an item from both the rear and the front end.
Working:
Create an empty array ‘arr’ of size N
initialize front = -1 , rear = 0
Inserting the First element in the deque, at either front or rear will lead to the same result:
Note: After inserting Front Points at 0 and Rear points at 0
Insert Elements at the Rear end of Deque:
a). First we check deque if Full or Not
b). IF Rear == Size-1
then reinitialize Rear = 0 ;
Else increment Rear by ‘1’
and push current key into Arr[ rear ] = key
Front remain same.
Insert Elements at the Front end of Deque:
a). First we check deque if Full or Not
b). IF Front == 0 || initial position, move Front
to points last index of array
front = size – 1
Else decremented front by ‘1’ and push
current key into Arr[ Front] = key
Rear remain same
Delete Element From Rear end of Deque:
First Check deque is Empty or Not
If deque has only one element
front = -1 ; rear =-1;Else IF Rear points to the first index of array
it’s means we have to move rear to points
last index [ now first inserted element at
front end become rear end ]rear = size-1;
Else || decrease rear by ‘1’ rear = rear-1;
Delete Element From the Front end of Deque:
a). first Check deque is Empty or Not
b). If deque has only one element
front = -1 ; rear =-1 ;Else IF front points to the last index of the array
it’s means we have no more elements in array so
we move front to points first index of array
front = 0 ;Else || increment Front by ‘1’
front = front+1;
Below is the implementation of the above methods:
// C++ implementation of De-queue using circular // array #include <iostream> using namespace std;
// Maximum size of array or Dequeue #define MAX 100 // A structure to represent a Deque class Deque {
int arr[MAX];
int front;
int rear;
int size;
public :
Deque( int size)
{
front = -1;
rear = 0;
this ->size = size;
}
// Operations on Deque:
void insertfront( int key);
void insertrear( int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear();
}; // Checks whether Deque is full or not. bool Deque::isFull()
{ return ((front == 0 && rear == size - 1)
|| front == rear + 1);
} // Checks whether Deque is empty or not. bool Deque::isEmpty() { return (front == -1); }
// Inserts an element at front void Deque::insertfront( int key)
{ // check whether Deque if full or not
if (isFull()) {
cout << "Overflow\n" << endl;
return ;
}
// If queue is initially empty
if (front == -1) {
front = 0;
rear = 0;
}
// front is at first position of queue
else if (front == 0)
front = size - 1;
else // decrement front end by '1'
front = front - 1;
// insert current element into Deque
arr[front] = key;
} // function to inset element at rear end // of Deque. void Deque ::insertrear( int key)
{ if (isFull()) {
cout << " Overflow\n " << endl;
return ;
}
// If queue is initially empty
if (front == -1) {
front = 0;
rear = 0;
}
// rear is at last position of queue
else if (rear == size - 1)
rear = 0;
// increment rear end by '1'
else
rear = rear + 1;
// insert current element into Deque
arr[rear] = key;
} // Deletes element at front end of Deque void Deque ::deletefront()
{ // check whether Deque is empty or not
if (isEmpty()) {
cout << "Queue Underflow\n" << endl;
return ;
}
// Deque has only one element
if (front == rear) {
front = -1;
rear = -1;
}
else
// back to initial position
if (front == size - 1)
front = 0;
else // increment front by '1' to remove current
// front value from Deque
front = front + 1;
} // Delete element at rear end of Deque void Deque::deleterear()
{ if (isEmpty()) {
cout << " Underflow\n" << endl;
return ;
}
// Deque has only one element
if (front == rear) {
front = -1;
rear = -1;
}
else if (rear == 0)
rear = size - 1;
else
rear = rear - 1;
} // Returns front element of Deque int Deque::getFront()
{ // check whether Deque is empty or not
if (isEmpty()) {
cout << " Underflow\n" << endl;
return -1;
}
return arr[front];
} // function return rear element of Deque int Deque::getRear()
{ // check whether Deque is empty or not
if (isEmpty() || rear < 0) {
cout << " Underflow\n" << endl;
return -1;
}
return arr[rear];
} // Driver code int main()
{ Deque dq(5);
// Function calls
cout << "Insert element at rear end : 5 \n" ;
dq.insertrear(5);
cout << "insert element at rear end : 10 \n" ;
dq.insertrear(10);
cout << "get rear element "
<< " " << dq.getRear() << endl;
dq.deleterear();
cout << "After delete rear element new rear"
<< " become " << dq.getRear() << endl;
cout << "inserting element at front end \n" ;
dq.insertfront(15);
cout << "get front element "
<< " " << dq.getFront() << endl;
dq.deletefront();
cout << "After delete front element new "
<< "front become " << dq.getFront() << endl;
return 0;
} |
// Java implementation of De-queue using circular // array // A structure to represent a Deque class Deque {
static final int MAX = 100 ;
int arr[];
int front;
int rear;
int size;
public Deque( int size)
{
arr = new int [MAX];
front = - 1 ;
rear = 0 ;
this .size = size;
}
/*// Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear();*/
// Checks whether Deque is full or not.
boolean isFull()
{
return ((front == 0 && rear == size - 1 )
|| front == rear + 1 );
}
// Checks whether Deque is empty or not.
boolean isEmpty() { return (front == - 1 ); }
// Inserts an element at front
void insertfront( int key)
{
// check whether Deque if full or not
if (isFull()) {
System.out.println( "Overflow" );
return ;
}
// If queue is initially empty
if (front == - 1 ) {
front = 0 ;
rear = 0 ;
}
// front is at first position of queue
else if (front == 0 )
front = size - 1 ;
else // decrement front end by '1'
front = front - 1 ;
// insert current element into Deque
arr[front] = key;
}
// function to inset element at rear end
// of Deque.
void insertrear( int key)
{
if (isFull()) {
System.out.println( " Overflow " );
return ;
}
// If queue is initially empty
if (front == - 1 ) {
front = 0 ;
rear = 0 ;
}
// rear is at last position of queue
else if (rear == size - 1 )
rear = 0 ;
// increment rear end by '1'
else
rear = rear + 1 ;
// insert current element into Deque
arr[rear] = key;
}
// Deletes element at front end of Deque
void deletefront()
{
// check whether Deque is empty or not
if (isEmpty()) {
System.out.println( "Queue Underflow\n" );
return ;
}
// Deque has only one element
if (front == rear) {
front = - 1 ;
rear = - 1 ;
}
else
// back to initial position
if (front == size - 1 )
front = 0 ;
else // increment front by '1' to remove current
// front value from Deque
front = front + 1 ;
}
// Delete element at rear end of Deque
void deleterear()
{
if (isEmpty()) {
System.out.println( " Underflow" );
return ;
}
// Deque has only one element
if (front == rear) {
front = - 1 ;
rear = - 1 ;
}
else if (rear == 0 )
rear = size - 1 ;
else
rear = rear - 1 ;
}
// Returns front element of Deque
int getFront()
{
// check whether Deque is empty or not
if (isEmpty()) {
System.out.println( " Underflow" );
return - 1 ;
}
return arr[front];
}
// function return rear element of Deque
int getRear()
{
// check whether Deque is empty or not
if (isEmpty() || rear < 0 ) {
System.out.println( " Underflow\n" );
return - 1 ;
}
return arr[rear];
}
// Driver code
public static void main(String[] args)
{
Deque dq = new Deque( 5 );
// Function calls
System.out.println(
"Insert element at rear end : 5 " );
dq.insertrear( 5 );
System.out.println(
"insert element at rear end : 10 " );
dq.insertrear( 10 );
System.out.println( "get rear element : "
+ dq.getRear());
dq.deleterear();
System.out.println(
"After delete rear element new rear become : "
+ dq.getRear());
System.out.println(
"inserting element at front end" );
dq.insertfront( 15 );
System.out.println( "get front element: "
+ dq.getFront());
dq.deletefront();
System.out.println(
"After delete front element new front become : "
+ +dq.getFront());
}
} |
# Python implementation of De-queue using circular # array # A structure to represent a Deque MAX = 100
class Deque:
def __init__( self , size):
self .arr = [ 0 ] * MAX
self .front = - 1
self .rear = 0
self .size = size
''' Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear(); '''
# Checks whether Deque is full or not.
def isFull( self ):
return (( self .front = = 0 and self .rear = = self .size - 1 ) or self .front = = self .rear + 1 )
# Checks whether Deque is empty or not.
def isEmpty( self ):
return ( self .front = = - 1 )
# Inserts an element at front
def insertfront( self , key):
# check whether Deque if full or not
if ( self .isFull()):
print ( "Overflow" )
return
# If queue is initially empty
if ( self .front = = - 1 ):
self .front = 0
self .rear = 0
# front is at first position of queue
elif ( self .front = = 0 ):
self .front = self .size - 1
else : # decrement front end by '1'
self .front = self .front - 1
# insert current element into Deque
self .arr[ self .front] = key
# function to inset element at rear end
# of Deque.
def insertrear( self , key):
if ( self .isFull()):
print ( " Overflow" )
return
# If queue is initially empty
if ( self .front = = - 1 ):
self .front = 0
self .rear = 0
# rear is at last position of queue
elif ( self .rear = = self .size - 1 ):
self .rear = 0
# increment rear end by '1'
else :
self .rear = self .rear + 1
# insert current element into Deque
self .arr[ self .rear] = key
# Deletes element at front end of Deque
def deletefront( self ):
# check whether Deque is empty or not
if ( self .isEmpty()):
print ( "Queue Underflow" )
return
# Deque has only one element
if ( self .front = = self .rear):
self .front = - 1
self .rear = - 1
else :
# back to initial position
if ( self .front = = self .size - 1 ):
self .front = 0
else : # increment front by '1' to remove current
# front value from Deque
self .front = self .front + 1
# Delete element at rear end of Deque
def deleterear( self ):
if ( self .isEmpty()):
print ( " Underflow" )
return
# Deque has only one element
if ( self .front = = self .rear):
self .front = - 1
self .rear = - 1
elif ( self .rear = = 0 ):
self .rear = self .size - 1
else :
self .rear = self .rear - 1
# Returns front element of Deque
def getFront( self ):
# check whether Deque is empty or not
if ( self .isEmpty()):
print ( " Underflow" )
return - 1
return self .arr[ self .front]
# function return rear element of Deque
def getRear( self ):
# check whether Deque is empty or not
if ( self .isEmpty() or self .rear < 0 ):
print ( " Underflow" )
return - 1
return self .arr[ self .rear]
# Driver code if __name__ = = "__main__" :
dq = Deque( 5 )
# Function calls
print ( "Insert element at rear end : 5 " )
dq.insertrear( 5 )
print ( "insert element at rear end : 10 " )
dq.insertrear( 10 )
print (f "get rear element : {dq.getRear()}" )
dq.deleterear()
print (f "After delete rear element new rear become : {dq.getRear()}" )
print ( "inserting element at front end" )
dq.insertfront( 15 )
print (f "get front element: {dq.getFront()}" )
dq.deletefront()
print (f "After delete front element new front become : {dq.getFront()}" )
# This code is contributed by _saurabh_jaiswal |
// C# implementation of De-queue using circular // array using System;
// A structure to represent a Deque public class Deque {
static readonly int MAX = 100;
int [] arr;
int front;
int rear;
int size;
public Deque( int size)
{
arr = new int [MAX];
front = -1;
rear = 0;
this .size = size;
}
/*// Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool .Count!=0;
int getFront();
int getRear();*/
// Checks whether Deque is full or not.
bool isFull()
{
return ((front == 0 && rear == size - 1)
|| front == rear + 1);
}
// Checks whether Deque is empty or not.
bool isEmpty() { return (front == -1); }
// Inserts an element at front
void insertfront( int key)
{
// check whether Deque if full or not
if (isFull()) {
Console.WriteLine( "Overflow" );
return ;
}
// If queue is initially empty
if (front == -1) {
front = 0;
rear = 0;
}
// front is at first position of queue
else if (front == 0)
front = size - 1;
else // decrement front end by '1'
front = front - 1;
// insert current element into Deque
arr[front] = key;
}
// function to inset element at rear end
// of Deque.
void insertrear( int key)
{
if (isFull()) {
Console.WriteLine( " Overflow " );
return ;
}
// If queue is initially empty
if (front == -1) {
front = 0;
rear = 0;
}
// rear is at last position of queue
else if (rear == size - 1)
rear = 0;
// increment rear end by '1'
else
rear = rear + 1;
// insert current element into Deque
arr[rear] = key;
}
// Deletes element at front end of Deque
void deletefront()
{
// check whether Deque is empty or not
if (isEmpty()) {
Console.WriteLine( "Queue Underflow\n" );
return ;
}
// Deque has only one element
if (front == rear) {
front = -1;
rear = -1;
}
else
// back to initial position
if (front == size - 1)
front = 0;
else // increment front by '1' to remove current
// front value from Deque
front = front + 1;
}
// Delete element at rear end of Deque
void deleterear()
{
if (isEmpty()) {
Console.WriteLine( " Underflow" );
return ;
}
// Deque has only one element
if (front == rear) {
front = -1;
rear = -1;
}
else if (rear == 0)
rear = size - 1;
else
rear = rear - 1;
}
// Returns front element of Deque
int getFront()
{
// check whether Deque is empty or not
if (isEmpty()) {
Console.WriteLine( " Underflow" );
return -1;
}
return arr[front];
}
// function return rear element of Deque
int getRear()
{
// check whether Deque is empty or not
if (isEmpty() || rear < 0) {
Console.WriteLine( " Underflow\n" );
return -1;
}
return arr[rear];
}
// Driver code
public static void Main(String[] args)
{
Deque dq = new Deque(5);
// Function calls
Console.WriteLine(
"Insert element at rear end : 5 " );
dq.insertrear(5);
Console.WriteLine(
"insert element at rear end : 10 " );
dq.insertrear(10);
Console.WriteLine( "get rear element : "
+ dq.getRear());
dq.deleterear();
Console.WriteLine(
"After delete rear element new rear become : "
+ dq.getRear());
Console.WriteLine( "inserting element at front end" );
dq.insertfront(15);
Console.WriteLine( "get front element: "
+ dq.getFront());
dq.deletefront();
Console.WriteLine(
"After delete front element new front become : "
+ +dq.getFront());
}
} // This code is contributed by aashish1995 |
<script> // Javascript implementation of De-queue using circular // array // A structure to represent a Deque let MAX = 100; class Deque { constructor(size)
{
this .arr = new Array(MAX);
this .front = -1;
this .rear = 0;
this .size = size;
}
/*// Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear();*/
// Checks whether Deque is full or not.
isFull()
{
return (( this .front == 0 && this .rear == this .size-1)||
this .front == this .rear+1);
}
// Checks whether Deque is empty or not.
isEmpty ()
{
return ( this .front == -1);
}
// Inserts an element at front
insertfront(key)
{
// check whether Deque if full or not
if ( this .isFull())
{
document.write( "Overflow<br>" );
return ;
}
// If queue is initially empty
if ( this .front == -1)
{
this .front = 0;
this .rear = 0;
}
// front is at first position of queue
else if ( this .front == 0)
this .front = this .size - 1 ;
else // decrement front end by '1'
this .front = this .front-1;
// insert current element into Deque
this .arr[ this .front] = key ;
}
// function to inset element at rear end
// of Deque.
insertrear(key)
{
if ( this .isFull())
{
document.write( " Overflow <br>" );
return ;
}
// If queue is initially empty
if ( this .front == -1)
{
this .front = 0;
this .rear = 0;
}
// rear is at last position of queue
else if ( this .rear == this .size-1)
this .rear = 0;
// increment rear end by '1'
else
this .rear = this .rear+1;
// insert current element into Deque
this .arr[ this .rear] = key ;
}
// Deletes element at front end of Deque
deletefront()
{
// check whether Deque is empty or not
if ( this .isEmpty())
{
document.write( "Queue Underflow<br>" );
return ;
}
// Deque has only one element
if ( this .front == this .rear)
{
this .front = -1;
this .rear = -1;
}
else
// back to initial position
if ( this .front == this .size -1)
this .front = 0;
else // increment front by '1' to remove current
// front value from Deque
this .front = this .front+1;
}
// Delete element at rear end of Deque
deleterear()
{
if ( this .isEmpty())
{
document.write( " Underflow<br>" );
return ;
}
// Deque has only one element
if ( this .front == this .rear)
{
this .front = -1;
this .rear = -1;
}
else if ( this .rear == 0)
this .rear = this .size-1;
else
this .rear = this .rear-1;
}
// Returns front element of Deque
getFront()
{
// check whether Deque is empty or not
if ( this .isEmpty())
{
document.write( " Underflow<br>" );
return -1 ;
}
return this .arr[ this .front];
}
// function return rear element of Deque
getRear()
{
// check whether Deque is empty or not
if ( this .isEmpty() || this .rear < 0)
{
document.write( " Underflow<br>" );
return -1 ;
}
return this .arr[ this .rear];
}
} // Driver program to test above function let dq = new Deque(5);
document.write( "Insert element at rear end : 5 <br>" );
dq.insertrear(5); document.write( "insert element at rear end : 10 <br>" );
dq.insertrear(10); document.write( "get rear element : " + dq.getRear()+ "<br>" );
dq.deleterear(); document.write( "After delete rear element new rear become : " +
dq.getRear()+ "<br>" );
document.write( "inserting element at front end<br>" );
dq.insertfront(15); document.write( "get front element: " +dq.getFront()+ "<br>" );
dq.deletefront(); document.write( "After delete front element new front become : " +
+ dq.getFront()+ "<br>" );
// This code is contributed by avanitrachhadiya2155 </script> |
Insert element at rear end : 5 insert element at rear end : 10 get rear element 10 After delete rear element new rear become 5 inserting element at front end get front element 15 After delete front element new front become 5
Time Complexity: O(N)
Auxiliary Space: O(N)