Deque : A linear data structure that allows insertion and deletion from both ends (front and rear). It is also called a Double Ended Queue.
Unlike Queue (FIFO), Deque provides flexibility to insert and remove elements from either side.
Operations of Deque:
insertFront(x)
- Insert element at the front
- Array (Circular): O(1)
- Doubly Linked List: O(1)
- Space: O(1)
insertRear(x)
- Insert element at the rear
- Array (Circular): O(1)
- Doubly Linked List: O(1)
- Space: O(1)
deleteFront()
- Remove element from the front
- Array (Circular): O(1)
- Doubly Linked List: O(1)
- Space: O(1)
deleteRear()
- Remove element from the rear
- Array (Circular): O(1)
- Doubly Linked List: O(1)
- Space: O(1)
getFront()
- View front element without removing
- Array / Linked List: O(1)
- Space: O(1)
getRear()
- View rear element without removing
- Array / Linked List: O(1)
- Space: O(1)
isEmpty()
- Check if deque is empty
- Array / Linked List: O(1)
isFull()
- Check if deque is full (only for fixed-size array)
- Array: O(1)
- Linked List: Not required (dynamic size)
Implementation of Deque:
Deque Implementation using Array (Circular Array):
Using an array with two pointers:
Pointers:
- front: Points to first element
- rear: Points to last element
Operations:
- insertFront(x): O(1)
- insertRear(x): O(1)
- deleteFront(): O(1)
- deleteRear(): O(1)
- getFront() / getRear(): O(1)
Advantages:
- Efficient O(1) operations
- No shifting required
- Better than normal array queue
Limitation:
- Fixed size
- Overflow possible if capacity is reached
#include <iostream>
using namespace std;
class myDeque {
int *arr;
int front, rear, size, capacity;
public:
// Constructor to initialize deque with given capacity
myDeque(int c) {
capacity = c;
arr = new int[c];
front = -1;
rear = 0;
size = 0;
}
// Check if deque is full
bool isFull() {
return size == capacity;
}
// Check if deque is empty
bool isEmpty() {
return size == 0;
}
// Insert element at front
void insertFront(int key) {
if (isFull()) {
cout << "Deque is full!\n";
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If front is at first position, wrap to last (circular behavior)
else if (front == 0)
front = capacity - 1;
// Otherwise decrement front
else
front--;
arr[front] = key;
size++;
}
// Insert element at rear
void insertRear(int key) {
if (isFull()) {
cout << "Deque is full!\n";
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If rear is at last position, wrap to first
else if (rear == capacity - 1)
rear = 0;
// Otherwise increment rear
else
rear++;
arr[rear] = key;
size++;
}
// Delete element from front
void deleteFront() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If front is at last position, wrap to first
else if (front == capacity - 1)
front = 0;
// Otherwise move front forward
else
front++;
size--;
}
// Delete element from rear
void deleteRear() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If rear is at first position, wrap to last
else if (rear == 0)
rear = capacity - 1;
// Otherwise move rear backward
else
rear--;
size--;
}
// Get front element
int getFront() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return -1;
}
return arr[front];
}
// Get rear element
int getRear() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return -1;
}
return arr[rear];
}
};
int main() {
// Create deque of capacity 3
myDeque dq(3);
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
cout << "Front: " << dq.getFront() << endl;
cout << "Rear: " << dq.getRear() << endl;
dq.deleteFront();
cout << "Front: " << dq.getFront() << endl;
return 0;
}
class myDeque {
int[] arr;
int front, rear;
int size;
int capacity;
// Constructor to initialize deque with given capacity
myDeque(int c) {
capacity = c;
arr = new int[c];
front = -1;
rear = 0;
size = 0;
}
// Check if deque is full
boolean isFull() {
return size == capacity;
}
// Check if deque is empty
boolean isEmpty() {
return size == 0;
}
// Insert element at front
void insertFront(int key) {
if (isFull()) {
System.out.println("Deque is full!");
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If front is at first position, wrap to last (circular behavior)
else if (front == 0)
front = capacity - 1;
// Otherwise decrement front
else
front--;
arr[front] = key;
size++;
}
// Insert element at rear
void insertRear(int key) {
if (isFull()) {
System.out.println("Deque is full!");
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If rear is at last position, wrap to first
else if (rear == capacity - 1)
rear = 0;
// Otherwise increment rear
else
rear++;
arr[rear] = key;
size++;
}
// Delete element from front
void deleteFront() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If front is at last position, wrap to first
else if (front == capacity - 1)
front = 0;
// Otherwise move front forward
else
front++;
size--;
}
// Delete element from rear
void deleteRear() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If rear is at first position, wrap to last
else if (rear == 0)
rear = capacity - 1;
// Otherwise move rear backward
else
rear--;
size--;
}
// Get front element
int getFront() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return -1;
}
return arr[front];
}
// Get rear element
int getRear() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return -1;
}
return arr[rear];
}
// Main method
public static void main(String[] args) {
// Create deque of capacity 3
myDeque dq = new myDeque(3);
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
System.out.println("Front: " + dq.getFront());
System.out.println("Rear: " + dq.getRear());
dq.deleteFront();
System.out.println("Front: " + dq.getFront());
}
}
class myDeque:
# Constructor to initialize deque with given capacity
def __init__(self, c):
self.capacity = c
self.arr = [0] * c
self.front = -1
self.rear = 0
self.size = 0
# Check if deque is full
def isFull(self):
return self.size == self.capacity
# Check if deque is empty
def isEmpty(self):
return self.size == 0
# Insert element at front
def insertFront(self, key):
if self.isFull():
print("Deque is full!")
return
# If deque is empty
if self.front == -1:
self.front = self.rear = 0
# If front is at first position, wrap to last (circular behavior)
elif self.front == 0:
self.front = self.capacity - 1
# Otherwise decrement front
else:
self.front -= 1
self.arr[self.front] = key
self.size += 1
# Insert element at rear
def insertRear(self, key):
if self.isFull():
print("Deque is full!")
return
# If deque is empty
if self.front == -1:
self.front = self.rear = 0
# If rear is at last position, wrap to first
elif self.rear == self.capacity - 1:
self.rear = 0
# Otherwise increment rear
else:
self.rear += 1
self.arr[self.rear] = key
self.size += 1
# Delete element from front
def deleteFront(self):
if self.isEmpty():
print("Deque is empty!")
return
# If only one element present
if self.front == self.rear:
self.front = self.rear = -1
# If front is at last position, wrap to first
elif self.front == self.capacity - 1:
self.front = 0
# Otherwise move front forward
else:
self.front += 1
self.size -= 1
# Delete element from rear
def deleteRear(self):
if self.isEmpty():
print("Deque is empty!")
return
# If only one element present
if self.front == self.rear:
self.front = self.rear = -1
# If rear is at first position, wrap to last
elif self.rear == 0:
self.rear = self.capacity - 1
# Otherwise move rear backward
else:
self.rear -= 1
self.size -= 1
# Get front element
def getFront(self):
if self.isEmpty():
print("Deque is empty!")
return -1
return self.arr[self.front]
# Get rear element
def getRear(self):
if self.isEmpty():
print("Deque is empty!")
return -1
return self.arr[self.rear]
if __name__ == "__main__":
# Create deque of capacity 3
dq = myDeque(3)
dq.insertRear(10)
dq.insertRear(20)
dq.insertFront(5)
print("Front:", dq.getFront())
print("Rear:", dq.getRear())
dq.deleteFront()
print("Front:", dq.getFront())
using System;
class myDeque {
int[] arr;
int front, rear;
int size;
int capacity;
// Constructor to initialize deque with given capacity
public myDeque(int c) {
capacity = c;
arr = new int[c];
front = -1;
rear = 0;
size = 0;
}
// Check if deque is full
public bool isFull() {
return size == capacity;
}
// Check if deque is empty
public bool isEmpty() {
return size == 0;
}
// Insert element at front
public void insertFront(int key) {
if (isFull()) {
Console.WriteLine("Deque is full!");
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If front is at first position, wrap to last (circular behavior)
else if (front == 0)
front = capacity - 1;
// Otherwise decrement front
else
front--;
arr[front] = key;
size++;
}
// Insert element at rear
public void insertRear(int key) {
if (isFull()) {
Console.WriteLine("Deque is full!");
return;
}
// If deque is empty
if (front == -1)
front = rear = 0;
// If rear is at last position, wrap to first
else if (rear == capacity - 1)
rear = 0;
// Otherwise increment rear
else
rear++;
arr[rear] = key;
size++;
}
// Delete element from front
public void deleteFront() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If front is at last position, wrap to first
else if (front == capacity - 1)
front = 0;
// Otherwise move front forward
else
front++;
size--;
}
// Delete element from rear
public void deleteRear() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return;
}
// If only one element present
if (front == rear)
front = rear = -1;
// If rear is at first position, wrap to last
else if (rear == 0)
rear = capacity - 1;
// Otherwise move rear backward
else
rear--;
size--;
}
// Get front element
public int getFront() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return -1;
}
return arr[front];
}
// Get rear element
public int getRear() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return -1;
}
return arr[rear];
}
static void Main(string[] args) {
// Create deque of capacity 3
myDeque dq = new myDeque(3);
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
Console.WriteLine("Front: " + dq.getFront());
Console.WriteLine("Rear: " + dq.getRear());
dq.deleteFront();
Console.WriteLine("Front: " + dq.getFront());
}
}
class myDeque {
// Constructor to initialize deque with given capacity
constructor(c) {
this.capacity = c;
this.arr = new Array(c);
this.front = -1;
this.rear = 0;
this.size = 0;
}
// Check if deque is full
isFull() {
return this.size === this.capacity;
}
// Check if deque is empty
isEmpty() {
return this.size === 0;
}
// Insert element at front
insertFront(key) {
if (this.isFull()) {
console.log("Deque is full!");
return;
}
// If deque is empty
if (this.front === -1)
this.front = this.rear = 0;
// If front is at first position, wrap to last (circular behavior)
else if (this.front === 0)
this.front = this.capacity - 1;
// Otherwise decrement front
else
this.front--;
this.arr[this.front] = key;
this.size++;
}
// Insert element at rear
insertRear(key) {
if (this.isFull()) {
console.log("Deque is full!");
return;
}
// If deque is empty
if (this.front === -1)
this.front = this.rear = 0;
// If rear is at last position, wrap to first
else if (this.rear === this.capacity - 1)
this.rear = 0;
// Otherwise increment rear
else
this.rear++;
this.arr[this.rear] = key;
this.size++;
}
// Delete element from front
deleteFront() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return;
}
// If only one element present
if (this.front === this.rear)
this.front = this.rear = -1;
// If front is at last position, wrap to first
else if (this.front === this.capacity - 1)
this.front = 0;
// Otherwise move front forward
else
this.front++;
this.size--;
}
// Delete element from rear
deleteRear() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return;
}
// If only one element present
if (this.front === this.rear)
this.front = this.rear = -1;
// If rear is at first position, wrap to last
else if (this.rear === 0)
this.rear = this.capacity - 1;
// Otherwise move rear backward
else
this.rear--;
this.size--;
}
// Get front element
getFront() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return -1;
}
return this.arr[this.front];
}
// Get rear element
getRear() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return -1;
}
return this.arr[this.rear];
}
}
// Create deque of capacity 3
let dq = new myDeque(3);
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
console.log("Front:", dq.getFront());
console.log("Rear:", dq.getRear());
dq.deleteFront();
console.log("Front:", dq.getFront());
Output
Front: 5 Rear: 20 Front: 10
Deque Implementation using Doubly Linked List:
Each node contains:
- prev
- data
- next
Pointers:
- frontPtr: Points to first node
- rearPtr: Points to last node
Operations:
- insertFront: O(1)
- insertRear: O(1)
- deleteFront: O(1)
- deleteRear: O(1)
- getFront / getRear: O(1)
Advantages:
- Dynamic size
- No overflow
- Efficient insertion and deletion
Limitation:
- Extra memory for prev pointer
#include <iostream>
using namespace std;
// Node class for Doubly Linked List
class Node {
public:
int data;
Node* prev;
Node* next;
Node(int val) {
data = val;
prev = nullptr;
next = nullptr;
}
};
class myDeque {
Node* front;
Node* rear;
int size;
public:
// Constructor to initialize empty deque
myDeque() {
front = rear = nullptr;
size = 0;
}
// Check if deque is empty
bool isEmpty() {
return front == nullptr;
}
// Insert element at front
void insertFront(int key) {
Node* newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
newNode->next = front;
front->prev = newNode;
front = newNode;
}
size++;
}
// Insert element at rear
void insertRear(int key) {
Node* newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
rear->next = newNode;
newNode->prev = rear;
rear = newNode;
}
size++;
}
// Delete element from front
void deleteFront() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return;
}
Node* temp = front;
// If only one element present
if (front == rear) {
front = rear = nullptr;
}
else {
front = front->next;
front->prev = nullptr;
}
delete temp;
size--;
}
// Delete element from rear
void deleteRear() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return;
}
Node* temp = rear;
// If only one element present
if (front == rear) {
front = rear = nullptr;
}
else {
rear = rear->prev;
rear->next = nullptr;
}
delete temp;
size--;
}
// Get front element
int getFront() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return -1;
}
return front->data;
}
// Get rear element
int getRear() {
if (isEmpty()) {
cout << "Deque is empty!\n";
return -1;
}
return rear->data;
}
};
int main() {
// Create deque
myDeque dq;
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
cout << "Front: " << dq.getFront() << endl;
cout << "Rear: " << dq.getRear() << endl;
dq.deleteFront();
cout << "Front: " << dq.getFront() << endl;
return 0;
}
// Node class for Doubly Linked List
class Node {
int data;
Node prev;
Node next;
Node(int val) {
data = val;
prev = null;
next = null;
}
}
class myDeque {
Node front;
Node rear;
int size;
// Constructor to initialize empty deque
myDeque() {
front = rear = null;
size = 0;
}
// Check if deque is empty
boolean isEmpty() {
return front == null;
}
// Insert element at front
void insertFront(int key) {
Node newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
newNode.next = front;
front.prev = newNode;
front = newNode;
}
size++;
}
// Insert element at rear
void insertRear(int key) {
Node newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
rear.next = newNode;
newNode.prev = rear;
rear = newNode;
}
size++;
}
// Delete element from front
void deleteFront() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return;
}
Node temp = front;
// If only one element present
if (front == rear) {
front = rear = null;
}
else {
front = front.next;
front.prev = null;
}
size--;
}
// Delete element from rear
void deleteRear() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return;
}
Node temp = rear;
// If only one element present
if (front == rear) {
front = rear = null;
}
else {
rear = rear.prev;
rear.next = null;
}
size--;
}
// Get front element
int getFront() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return -1;
}
return front.data;
}
// Get rear element
int getRear() {
if (isEmpty()) {
System.out.println("Deque is empty!");
return -1;
}
return rear.data;
}
public static void main(String[] args) {
// Create deque
myDeque dq = new myDeque();
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
System.out.println("Front: " + dq.getFront());
System.out.println("Rear: " + dq.getRear());
dq.deleteFront();
System.out.println("Front: " + dq.getFront());
}
}
# Node class for Doubly Linked List
class Node:
def __init__(self, val):
self.data = val
self.prev = None
self.next = None
class myDeque:
# Constructor to initialize empty deque
def __init__(self):
self.front = None
self.rear = None
self.size = 0
# Check if deque is empty
def isEmpty(self):
return self.front is None
# Insert element at front
def insertFront(self, key):
newNode = Node(key)
# If deque is empty
if self.isEmpty():
self.front = self.rear = newNode
else:
newNode.next = self.front
self.front.prev = newNode
self.front = newNode
self.size += 1
# Insert element at rear
def insertRear(self, key):
newNode = Node(key)
# If deque is empty
if self.isEmpty():
self.front = self.rear = newNode
else:
self.rear.next = newNode
newNode.prev = self.rear
self.rear = newNode
self.size += 1
# Delete element from front
def deleteFront(self):
if self.isEmpty():
print("Deque is empty!")
return
temp = self.front
# If only one element present
if self.front == self.rear:
self.front = self.rear = None
else:
self.front = self.front.next
self.front.prev = None
self.size -= 1
# Delete element from rear
def deleteRear(self):
if self.isEmpty():
print("Deque is empty!")
return
temp = self.rear
# If only one element present
if self.front == self.rear:
self.front = self.rear = None
else:
self.rear = self.rear.prev
self.rear.next = None
self.size -= 1
# Get front element
def getFront(self):
if self.isEmpty():
print("Deque is empty!")
return -1
return self.front.data
# Get rear element
def getRear(self):
if self.isEmpty():
print("Deque is empty!")
return -1
return self.rear.data
if __name__ == "__main__":
# Create deque
dq = myDeque()
dq.insertRear(10)
dq.insertRear(20)
dq.insertFront(5)
print("Front:", dq.getFront())
print("Rear:", dq.getRear())
dq.deleteFront()
print("Front:", dq.getFront())
using System;
// Node class for Doubly Linked List
class Node {
public int data;
public Node prev;
public Node next;
public Node(int val) {
data = val;
prev = null;
next = null;
}
}
class myDeque {
Node front;
Node rear;
int size;
// Constructor to initialize empty deque
public myDeque() {
front = rear = null;
size = 0;
}
// Check if deque is empty
public bool isEmpty() {
return front == null;
}
// Insert element at front
public void insertFront(int key) {
Node newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
newNode.next = front;
front.prev = newNode;
front = newNode;
}
size++;
}
// Insert element at rear
public void insertRear(int key) {
Node newNode = new Node(key);
// If deque is empty
if (isEmpty()) {
front = rear = newNode;
}
else {
rear.next = newNode;
newNode.prev = rear;
rear = newNode;
}
size++;
}
// Delete element from front
public void deleteFront() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return;
}
Node temp = front;
// If only one element present
if (front == rear) {
front = rear = null;
}
else {
front = front.next;
front.prev = null;
}
size--;
}
// Delete element from rear
public void deleteRear() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return;
}
Node temp = rear;
// If only one element present
if (front == rear) {
front = rear = null;
}
else {
rear = rear.prev;
rear.next = null;
}
size--;
}
// Get front element
public int getFront() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return -1;
}
return front.data;
}
// Get rear element
public int getRear() {
if (isEmpty()) {
Console.WriteLine("Deque is empty!");
return -1;
}
return rear.data;
}
static void Main(string[] args) {
// Create deque
myDeque dq = new myDeque();
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
Console.WriteLine("Front: " + dq.getFront());
Console.WriteLine("Rear: " + dq.getRear());
dq.deleteFront();
Console.WriteLine("Front: " + dq.getFront());
}
}
// Node class for Doubly Linked List
class Node {
constructor(val) {
this.data = val;
this.prev = null;
this.next = null;
}
}
class myDeque {
// Constructor to initialize empty deque
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
// Check if deque is empty
isEmpty() {
return this.front === null;
}
// Insert element at front
insertFront(key) {
let newNode = new Node(key);
// If deque is empty
if (this.isEmpty()) {
this.front = this.rear = newNode;
}
else {
newNode.next = this.front;
this.front.prev = newNode;
this.front = newNode;
}
this.size++;
}
// Insert element at rear
insertRear(key) {
let newNode = new Node(key);
// If deque is empty
if (this.isEmpty()) {
this.front = this.rear = newNode;
}
else {
this.rear.next = newNode;
newNode.prev = this.rear;
this.rear = newNode;
}
this.size++;
}
// Delete element from front
deleteFront() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return;
}
let temp = this.front;
// If only one element present
if (this.front === this.rear) {
this.front = this.rear = null;
}
else {
this.front = this.front.next;
this.front.prev = null;
}
this.size--;
}
// Delete element from rear
deleteRear() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return;
}
let temp = this.rear;
// If only one element present
if (this.front === this.rear) {
this.front = this.rear = null;
}
else {
this.rear = this.rear.prev;
this.rear.next = null;
}
this.size--;
}
// Get front element
getFront() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return -1;
}
return this.front.data;
}
// Get rear element
getRear() {
if (this.isEmpty()) {
console.log("Deque is empty!");
return -1;
}
return this.rear.data;
}
}
// Create deque
let dq = new myDeque();
dq.insertRear(10);
dq.insertRear(20);
dq.insertFront(5);
console.log("Front:", dq.getFront());
console.log("Rear:", dq.getRear());
dq.deleteFront();
console.log("Front:", dq.getFront());
Output
Front: 5 Rear: 20 Front: 10
