Deque Data Structure

Deque is a hybrid data structure that combines the features of a stack and a queue. It allows us to insert and delete elements from both ends of the queue. The name Deque is an abbreviation of Double-Ended Queue.

Imagine an event where you have two gates to enter and exit a place. People are entering from the front gate and some are entering from the side gate. Now, when people are leaving, they are leaving from the front gate and some sneak from the side gate. Now, we need to manage flow of people from both ends. This is where Deque comes into play.

Operations on Deque

Following are the major operations on Deque −

• push_front(x): Insert element x at the front of the deque.
• push_back(x): Insert element x at the back of the deque.
• pop_front(): Remove the element from the front of the deque.
• pop_back(): Remove the element from the back of the deque.
• peek_front(): Get the element from the front of the deque.
• peek_back(): Get the element from the back of the deque.
• size(): Get the number of elements in the deque.
• isEmpty(): Check if the deque is empty.

Implementation of Deque

Let's understand how we can implement deque using array. For this, we need to maintain two pointers, front and rear, to keep track of the front and back of the deque. We also need to define the size of the deque.

The push_front(x) Operation on Deque

When we insert an element at the front of the deque, we need to shift all the elements to the right by one position. We will increment the front pointer by one and insert the element at the front of the deque.

Algorithm for push_front(x)

Following are the steps to insert an element at the front of the deque −

 1. Check if the deque is full. If it is full, return an error message. 2. Increment the front pointer by one. 3. Insert the element at the front position. 4. Increment the size of the deque. 

implementation

Following is the implementation of push_front(x) operation on deque.

 #include <stdio.h> #include <stdlib.h> #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full int isFull() { return (front == 0 && rear == SIZE - 1) || (front == rear + 1); } // Check if the deque is empty int isEmpty() { return front == -1; } // Insert element at the front void push_front(int element) { if (isFull()) { printf("Deque is full\n"); return; } if (isEmpty()) { // First element being inserted front = rear = 0; } else { // Circularly move front pointer front = (front - 1 + SIZE) % SIZE; } deque[front] = element; printf("Inserted -> %d\n", element); } // Display the deque void display() { if (isEmpty()) { printf("Empty Deque\n"); return; } int i = front; printf("Elements -> "); while (1) { printf("%d ", deque[i]); if (i == rear) break; // Stop at the last element i = (i + 1) % SIZE; // Circular increment } printf("\n"); } int main() { push_front(1); push_front(2); push_front(3); push_front(4); push_front(5); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 5 4 3 2 1 

 #include <iostream> using namespace std; #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full bool isFull() { return (front == 0 && rear == SIZE - 1) || (front == rear + 1); } // Check if the deque is empty bool isEmpty() { return front == -1; } // Insert element at the front void push_front(int element) { if (isFull()) { cout << "Deque is full" << endl; return; } if (isEmpty()) { // First element being inserted front = rear = 0; } else if (front == 0) { // Wrap around front = SIZE - 1; } else { front--; } deque[front] = element; cout << "Inserted -> " << element << endl; } // Display the deque void display() { if (isEmpty()) { cout << "Empty Deque" << endl; return; } cout << "Elements -> "; int i = front; while (true) { cout << deque[i] << " "; if (i == rear) break; // Stop at last element i = (i + 1) % SIZE; // Circular increment } cout << endl; } int main() { push_front(1); push_front(2); push_front(3); push_front(4); push_front(5); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 5 4 3 2 1 

 //Java Program class Deque { static final int SIZE = 5; static int deque[] = new int[SIZE]; static int front = -1, rear = -1; // Check if the deque is full static boolean isFull() { return (front == 0 && rear == SIZE - 1) || (front == rear + 1); } // Check if the deque is empty static boolean isEmpty() { if (front == -1) return true; return false; } // Insert element at the front static void push_front(int element) { if (isFull()) System.out.println("Deque is full"); if(isEmpty()) { front = rear = 0; }else { front = (front - 1 + SIZE) % SIZE; } deque[front] = element; System.out.println("Inserted -> " + element); } // Display the deque static void display() { if (isEmpty()) System.out.println("Empty Deque"); System.out.print("Elements -> "); int i = front; while (true) { System.out.print(deque[i] + " "); if (i == rear) break; i = (i + 1) % SIZE; } System.out.println(); } } public class Main{ public static void main(String[] args) { Deque deque = new Deque(); deque.push_front(1); deque.push_front(2); deque.push_front(3); deque.push_front(4); deque.push_front(5); deque.display(); } } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 5 4 3 2 1 

 SIZE = 5 deque = [0] * SIZE front = -1 rear = -1 # Check if the deque is full def isFull(): return (front == 0 and rear == SIZE - 1) or (front == rear + 1) # Check if the deque is empty def isEmpty(): return front == -1 # Insert element at the front def push_front(element): global front, rear if isFull(): print("Deque is full") if isEmpty(): front = rear = 0 else: front = (front - 1 + SIZE) % SIZE deque[front] = element print("Inserted ->", element) # Display the deque def display(): global front, rear if isEmpty(): print("Empty Deque") else: i = front print("Elements ->", end=" ") while i != rear: print(deque[i], end=" ") i = (i + 1) % SIZE print(deque[rear]) # Print the last element # Testing the functions push_front(1) push_front(2) push_front(3) push_front(4) push_front(5) display() 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 5 4 3 2 1 

push_back(x) Operation

This operation is used for inserting an element to the back of the deque. When we insert an element at the back of the deque, we need to increment the rear pointer by one and insert the element at the back of the deque.

Algorithm for push_back(x)

Following are the steps to insert an element at the back of the deque −

 1. Check if the deque is full. 2. Increment the rear pointer by one. 3. Insert the element at the rear position. 4. Increment the size of the deque. 

Implementation

Following is the implementation of push_back(x) operation on deque.

 //C Program #include <stdio.h> #include <stdlib.h> #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full int isFull() { return ((front == 0 && rear == SIZE - 1) || (front == rear + 1)); } // Check if the deque is empty int isEmpty() { return (front == -1); } // Insert element at the back void push_back(int element) { if (isFull()) { printf("Deque is full\n"); } else { if (front == -1) { // If deque is initially empty front = rear = 0; } else if (rear == SIZE - 1) { // Wrap around to the front rear = 0; } else { rear++; } deque[rear] = element; printf("Inserted -> %d\n", element); } } // Display the deque void display() { if (isEmpty()) { printf("Empty Deque\n"); } else { printf("Elements -> "); int i = front; while (1) { printf("%d ", deque[i]); if (i == rear) break; // Stop when the rear is reached i = (i + 1) % SIZE; // Circular increment } printf("\n"); } } // Main function int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 1 2 3 4 5 

 #include <iostream> using namespace std; #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full bool isFull() { return (front == 0 && rear == SIZE - 1) || (front == rear + 1); } // Check if the deque is empty bool isEmpty() { return front == -1; } // Insert element at the back void push_back(int element) { if (isFull()) { cout << "Deque is full" << endl; } else { if (front == -1) { // First insertion front = 0; rear = 0; } else if (rear == SIZE - 1 && front != 0) { // Wrap around rear = 0; } else { // Normal case rear++; } deque[rear] = element; cout << "Inserted -> " << element << endl; } } // Display the deque void display() { if (isEmpty()) { cout << "Empty Deque" << endl; } else { cout << "Elements -> "; int i = front; while (true) { cout << deque[i] << " "; if (i == rear) break; // Stop when the last element is printed i = (i + 1) % SIZE; // Move circularly } cout << endl; } } int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 1 2 3 4 5 

 //Java Program class Deque { static final int SIZE = 5; static int deque[] = new int[SIZE]; static int front = -1, rear = -1; // Check if the deque is full static boolean isFull() { if ((front == 0 && rear == SIZE - 1) || front == rear + 1) return true; return false; } // Check if the deque is empty static boolean isEmpty() { if (front == -1) return true; return false; } // Insert element at the back static void push_back(int element) { if (isFull()) System.out.println("Deque is full"); else { if (front == -1) front = 0; if (rear == SIZE - 1) rear = 0; else rear = rear + 1; deque[rear] = element; System.out.println("Inserted -> " + element); } } // Display the deque static void display() { int i = front; if (isEmpty()) System.out.println("Empty Deque"); else { System.out.print("Elements -> "); for (i = front; i != rear; i = (i + 1) % SIZE) { System.out.print(deque[i] + " "); } System.out.print(deque[i]); } } } public class Main{ public static void main(String[] args) { Deque deque = new Deque(); deque.push_back(1); deque.push_back(2); deque.push_back(3); deque.push_back(4); deque.push_back(5); deque.display(); } } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 1 2 3 4 5 

 #Python Program SIZE = 5 deque = [0] * SIZE front = -1 rear = -1 # Check if the deque is full def isFull(): if (front == 0 and rear == SIZE - 1) or (front == rear + 1): return True return False # Check if the deque is empty def isEmpty(): if front == -1: return True return False # Insert element at the back def push_back(element): global front, rear if isFull(): print("Deque is full") else: if front == -1: # Initial insertion front = 0 rear = 0 elif rear == SIZE - 1 and front != 0: # Wrap around rear = 0 else: # Normal case rear += 1 deque[rear] = element print("Inserted ->", element) # Display the deque def display(): global front, rear if isEmpty(): print("Empty Deque") else: print("Elements ->", end=" ") i = front while True: print(deque[i], end=" ") if i == rear: # Stop when we reach the last element break i = (i + 1) % SIZE # Move to the next index, circularly print() # Test the deque push_back(1) push_back(2) push_back(3) push_back(4) push_back(5) display() 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Elements -> 1 2 3 4 5 

The pop_front() and pop_back() Operations on Deque

These operation is done when we need to remove elements from front or back. When we remove an element from the front of the deque, we need to increment the front pointer by one.

Similarly, when we remove an element from the back of the deque, we need to decrement the rear pointer by one.

Algorithm for pop_front() and pop_back()

Following are the steps to remove an element from the front or back of the deque −

 1. Check if the deque is empty. 2. Remove the element from the front or back of the deque. 3. Increment or decrement the front or rear pointer. 4. Decrement the size of the deque. 

Implementation

Following is the implementation of pop_front() and pop_back() operations on deque.

 //C Program #include <stdio.h> #include <stdlib.h> #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full int isFull() { return ((front == 0 && rear == SIZE - 1) || (front == rear + 1)); } // Check if the deque is empty int isEmpty() { return (front == -1); } // Insert element at the back void push_back(int element) { if (isFull()) { printf("Deque is full\n"); } else { if (front == -1) { // If deque is initially empty front = rear = 0; } else if (rear == SIZE - 1) { // Wrap around to the front rear = 0; } else { rear++; } deque[rear] = element; printf("Inserted -> %d\n", element); } } // Remove element from the front void pop_front() { if (isEmpty()) { printf("Deque is empty\n"); } else { printf("Deleted from front -> %d\n", deque[front]); if (front == rear) { // If only one element is present front = rear = -1; } else { front = (front + 1) % SIZE; } } } // Remove element from the back void pop_back() { if (isEmpty()) { printf("Deque is empty\n"); } else { printf("Deleted from back -> %d\n", deque[rear]); if (front == rear) { // If only one element is present front = rear = -1; } else if (rear == 0) { rear = SIZE - 1; } else { rear--; } } } // Display the deque void display() { if (isEmpty()) { printf("Empty Deque\n"); } else { printf("Elements -> "); int i = front; while (1) { printf("%d ", deque[i]); if (i == rear) break; // Stop when the rear is reached i = (i + 1) % SIZE; // Circular increment } printf("\n"); } } // Main function int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); pop_front(); pop_back(); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Deleted -> 1 Deleted -> 5 

 //C++ Program #include <iostream> using namespace std; #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full bool isFull() { if ((front == 0 && rear == SIZE - 1) || front == rear + 1) return true; return false; } // Check if the deque is empty bool isEmpty() { if (front == -1) return true; return false; } // Insert element at the back void push_back(int element) { if (isFull()) cout << "Deque is full" << endl; else { if (front == -1) front = 0; if (rear == SIZE - 1) rear = 0; else rear = rear + 1; deque[rear] = element; cout << "Inserted -> " << element << endl; } } // Remove element from the front void pop_front() { if (isEmpty()) cout << "Deque is empty" << endl; else { cout << "Deleted from front -> " << deque[front] << endl; if (front == rear) front = rear = -1; else front = (front + 1) % SIZE; } } // Remove element from the back void pop_back() { if (isEmpty()) cout << "Deque is empty" << endl; else { cout << "Deleted from back -> " << deque[rear] << endl; if (front == rear) front = rear = -1; else if (rear == 0) rear = SIZE - 1; else rear = rear - 1; } } // Display the deque void display() { int i = front; if (isEmpty()) cout << "Empty Deque" << endl; else { cout << "Elements -> "; for (int i = front; i != rear; i = (i + 1) % SIZE) { cout << deque[i] << " "; } cout << deque[i]; } } int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); pop_front(); pop_back(); display(); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Deleted from front -> 1 Deleted from back -> 5 Elements -> 2 3 4 

 //Java Program class Deque { static final int SIZE = 5; static int deque[] = new int[SIZE]; static int front = -1, rear = -1; // Check if the deque is full static boolean isFull() { if ((front == 0 && rear == SIZE - 1) || front == rear + 1) return true; return false; } // Check if the deque is empty static boolean isEmpty() { if (front == -1) return true; return false; } // Insert element at the back static void push_back(int element) { if (isFull()) System.out.println("Deque is full"); else { if (front == -1) front = 0; if (rear == SIZE - 1) rear = 0; else rear = rear + 1; deque[rear] = element; System.out.println("Inserted -> " + element); } } // Remove element from the front static void pop_front() { if (isEmpty()) System.out.println("Deque is empty"); else { System.out.println("Deleted from front -> " + deque[front]); if (front == rear) front = rear = -1; else front = (front + 1) % SIZE; } } // Remove element from the back static void pop_back() { if (isEmpty()) System.out.println("Deque is empty"); else { System.out.println("Deleted from back -> " + deque[rear]); if (front == rear) front = rear = -1; else if (rear == 0) rear = SIZE - 1; else rear = rear - 1; } } // Display the deque static void display() { int i = front; if (isEmpty()) System.out.println("Empty Deque"); else { System.out.print("Elements -> "); for (i = front; i != rear; i = (i + 1) % SIZE) { System.out.print(deque[i] + " "); } System.out.print(deque[i]); } } } public class Main{ public static void main(String[] args) { Deque deque = new Deque(); deque.push_back(1); deque.push_back(2); deque.push_back(3); deque.push_back(4); deque.push_back(5); deque.pop_front(); deque.pop_back(); deque.display(); } } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Deleted from front -> 1 Deleted from back -> 5 Elements -> 2 3 4 

 #Python Program SIZE = 5 deque = [0] * SIZE front = -1 rear = -1 # Check if the deque is full def isFull(): if (front == 0 and rear == SIZE - 1) or front == rear + 1: return True return False # Check if the deque is empty def isEmpty(): if front == -1: return True return False # Insert element at the back def push_back(element): global front global rear if isFull(): print("Deque is full") else: if front == -1: front = 0 if rear == SIZE - 1: rear = 0 else: rear = rear + 1 deque[rear] = element print("Inserted ->", element) # Remove element from the front def pop_front(): global front global rear if isEmpty(): print("Deque is empty") else: print("Deleted from front ->", deque[front]) if front == rear: front = rear = -1 else: front = (front + 1) % SIZE # Remove element from the back def pop_back(): global front global rear if isEmpty(): print("Deque is empty") else: print("Deleted from back ->", deque[rear]) if front == rear: front = rear = -1 elif rear == 0: rear = SIZE - 1 else: rear = rear - 1 # Display the deque def display(): i = front if isEmpty(): print("Empty Deque") else: print("Elements ->", end = " ") while True: print(deque[i], end = " ") if i == rear: break i = (i + 1) % SIZE print(deque[rear]) push_back(1) push_back(2) push_back(3) push_back(4) push_back(5) pop_front() pop_back() display() 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Deleted from front -> 1 Deleted from back -> 5 Elements -> 2 3 4 

The peek_front() and peek_back() Operations on Deque

When we want to get the element from the front or back of the deque, we can use the peek_front() and peek_back() operations.

Algorithm for peek_front() and peek_back()

Following are the steps to get the element from the front or back of the deque −

 1. Check if the deque is empty. 2. If not empty, return the element from the front or back of the deque. 

Implementation

Following is the implementation code of peek_front() and peek_back() operations on deque.

 //C Program #include <stdio.h> #include <stdlib.h> #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full int isFull() { return ((front == 0 && rear == SIZE - 1) || (front == rear + 1)); } // Check if the deque is empty int isEmpty() { return (front == -1); } // Insert element at the back void push_back(int element) { if (isFull()) { printf("Deque is full\n"); } else { if (front == -1) { // If deque is initially empty front = rear = 0; } else if (rear == SIZE - 1) { // Wrap around to the front rear = 0; } else { rear++; } deque[rear] = element; printf("Inserted -> %d\n", element); } } // Get the element from the front int peek_front() { if (isEmpty()) { printf("Deque is empty\n"); return -1; } else { return deque[front]; } } // Get the element from the back int peek_back() { if (isEmpty()) { printf("Deque is empty\n"); return -1; } else { return deque[rear]; } } // Main function int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); printf("\nElement at front: %d\n", peek_front()); printf("Element at back: %d\n", peek_back()); return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Element at front: 1 Element at back: 5 

 //C++ Program #include <iostream> using namespace std; #define SIZE 5 int deque[SIZE]; int front = -1, rear = -1; // Check if the deque is full bool isFull() { if ((front == 0 && rear == SIZE - 1) || front == rear + 1) return true; return false; } // Check if the deque is empty bool isEmpty() { if (front == -1) return true; return false; } // Insert element at the back void push_back(int element) { if (isFull()) cout << "Deque is full" << endl; else { if (front == -1) front = 0; if (rear == SIZE - 1) rear = 0; else rear = rear + 1; deque[rear] = element; cout << "Inserted -> " << element << endl; } } // Get the element from the front int peek_front() { if (isEmpty()) { cout << "Deque is empty" << endl; return -1; } else { return deque[front]; } } // Get the element from the back int peek_back() { if (isEmpty()) { cout << "Deque is empty" << endl; return -1; } else { return deque[rear]; } } int main() { push_back(1); push_back(2); push_back(3); push_back(4); push_back(5); cout << "\nElement at front: " << peek_front() << endl; cout << "Element at back: " << peek_back() << endl; return 0; } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Element at front: 1 Element at back: 5 

 //Java Program class PeekFrontAndBack{ static final int SIZE = 5; static int deque[] = new int[SIZE]; static int front = -1, rear = -1; // Check if the deque is full static boolean isFull() { if ((front == 0 && rear == SIZE - 1) || front == rear + 1) return true; return false; } // Check if the deque is empty static boolean isEmpty() { if (front == -1) return true; return false; } // Insert element at the back static void push_back(int element) { if (isFull()) System.out.println("Deque is full"); else { if (front == -1) front = 0; if (rear == SIZE - 1) rear = 0; else rear = rear + 1; deque[rear] = element; System.out.println("Inserted -> " + element); } } // Get the element from the front static int peek_front() { if (isEmpty()) { System.out.println("Deque is empty"); return -1; } else { return deque[front]; } } // Get the element from the back static int peek_back() { if (isEmpty()) { System.out.println("Deque is empty"); return -1; } else { return deque[rear]; } } } public class Main{ public static void main(String[] args) { PeekFrontAndBack deque = new PeekFrontAndBack(); deque.push_back(1); deque.push_back(2); deque.push_back(3); deque.push_back(4); deque.push_back(5); System.out.println("\nElement at front: " + deque.peek_front()); System.out.println("Element at back: " + deque.peek_back()); } } 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Element at front: 1 Element at back: 5 

 #Python Program SIZE = 5 deque = [0] * SIZE front = -1 rear = -1 # Check if the deque is full def isFull(): if (front == 0 and rear == SIZE - 1) or front == rear + 1: return True return False # Check if the deque is empty def isEmpty(): if front == -1: return True return False # Insert element at the back def push_back(element): global front global rear if isFull(): print("Deque is full") else: if front == -1: front = 0 if rear == SIZE - 1: rear = 0 else: rear = rear + 1 deque[rear] = element print("Inserted ->", element) # Get the element from the front def peek_front(): if isEmpty(): print("Deque is empty") return -1 else: return deque[front] # Get the element from the back def peek_back(): if isEmpty(): print("Deque is empty") return -1 else: return deque[rear] push_back(1) push_back(2) push_back(3) push_back(4) push_back(5) print("\nElement at front:", peek_front()) print("Element at back:", peek_back()) 

 Inserted -> 1 Inserted -> 2 Inserted -> 3 Inserted -> 4 Inserted -> 5 Element at front: 1 Element at back: 5 

Time Complexity of Deque Operations

The time complexity of the deque operations is as follows −

• push_front(x) − O(1)
• push_back(x) − O(1)
• pop_front() − O(1)
• pop_back() − O(1)
• peek_front() − O(1)
• peek_back() − O(1)

Thus, the deque operations have a time complexity of O(1).

Applications of Deque

Some of the applications of deque are as follows −

• Deque is used for undo operation in text editors.
• It is also used in implementation of the sliding window algorithm.
• Deque is used in implementing the data structures like double-ended priority queue and double-ended stack.

In summary, we use deque when we need to perform insertion and deletion operations at both ends of the data structure.