Design Circular Deque - Practice Coding Problems

Design Circular Deque - Problem

Design and implement a Circular Double-Ended Queue (Deque) data structure that supports insertion and deletion operations from both ends efficiently.

A circular deque is a linear data structure that connects the rear and front ends, forming a circle. This design allows for optimal space utilization by reusing empty slots created after deletions.

Your task: Implement the MyCircularDeque class with the following methods:

MyCircularDeque(int k) - Initialize with maximum capacity k
insertFront(int value) - Add element at front, return true if successful
insertLast(int value) - Add element at rear, return true if successful
deleteFront() - Remove front element, return true if successful
deleteLast() - Remove rear element, return true if successful
getFront() - Get front element, return -1 if empty
getRear() - Get rear element, return -1 if empty
isEmpty() - Check if deque is empty
isFull() - Check if deque is full

All operations should run in O(1) time complexity!

Input & Output

example_1.py — Basic Operations

$ Input: ["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"] [[3], [1], [2], [3], [4], [], [], [], [4], []]

› Output: [null, true, true, true, false, 2, true, true, true, 4]

💡 Note: Initialize deque with capacity 3. Insert 1,2 at rear, then 3 at front. Try to insert 4 at front (fails - full). Get rear element (2). Check if full (true). Delete rear element. Insert 4 at front. Get front element (4).

example_2.py — Front and Rear Mix

$ Input: ["MyCircularDeque", "insertFront", "getRear", "insertLast", "getFront", "insertFront", "deleteLast", "getRear", "insertLast"] [[2], [7], [], [5], [], [1], [], [], [3]]

› Output: [null, true, 7, true, 7, false, true, 7, true]

💡 Note: Capacity 2 deque. Insert 7 at front. Get rear (7 - same element). Insert 5 at last. Get front (still 7). Try insert 1 at front (fails - full). Delete last element (5). Get rear (7). Insert 3 at last.

example_3.py — Edge Cases

$ Input: ["MyCircularDeque", "isEmpty", "insertFront", "isEmpty", "deleteFront", "isEmpty", "getFront", "getRear"] [[1], [], [1], [], [], [], [], []]

› Output: [null, true, true, false, true, true, -1, -1]

💡 Note: Single capacity deque. Check empty (true). Insert 1 at front. Check empty (false). Delete front. Check empty (true again). Get front/rear from empty deque (both return -1).

Visualization

Tap to expand

Understanding the Visualization

Initialize

Create empty circular array with front and rear pointers at position 0

Insert Front

Move front pointer backward (with wrap-around) and insert element

Insert Last

Insert element at rear position and move rear pointer forward

Full Detection

Deque is full when (rear + 1) % capacity equals front pointer

Wrap Around

Pointers seamlessly wrap from end back to beginning using modulo operation

Key Takeaway

🎯 Key Insight: Using modular arithmetic to treat a linear array as circular enables O(1) operations at both ends, making this the optimal solution for deque implementation.

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations use direct index access with simple arithmetic

✓ Linear Growth

Space Complexity

O(k)

Uses array of size k+1 to store up to k elements

✓ Linear Space

Constraints

1 ≤ k ≤ 1000
0 ≤ value ≤ 1000
At most 2000 calls will be made to all methods combined
All values will be in the range [0, 1000]

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The optimal solution uses a circular array with two pointers to achieve O(1) time complexity for all operations. Key insights: use modular arithmetic for wrap-around behavior, allocate one extra slot to distinguish between full and empty states, and maintain separate front/rear pointers that move efficiently around the circular buffer.

Common Approaches

Approach	Time	Space	Notes
✓ Array with Linear Shifts	O(n)	O(k)	Use regular array and shift elements for every insertion/deletion
Circular Array with Two Pointers (Optimal)	O(1)	O(k)	Use circular array with front and rear pointers, achieving O(1) for all operations

Array with Linear Shifts — Algorithm Steps

Use a regular array to store elements
For front insertion: shift all elements right, then insert at index 0
For front deletion: shift all elements left after removing index 0
For rear operations: simply add/remove from the end
Keep track of current size

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Empty deque with fixed capacity

Insert Front

Shift all existing elements right, then insert at index 0

Insert Last

Simply add to the end without shifting

Delete Front

Remove first element and shift all others left

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int* data;
    int capacity;
    int size;
} MyCircularDeque;

MyCircularDeque* myCircularDequeCreate(int k) {
    MyCircularDeque* obj = (MyCircularDeque*)malloc(sizeof(MyCircularDeque));
    obj->data = (int*)malloc(k * sizeof(int));
    obj->capacity = k;
    obj->size = 0;
    return obj;
}

bool myCircularDequeInsertFront(MyCircularDeque* obj, int value) {
    if (obj->size == obj->capacity) return false;
    // Shift all elements right
    for (int i = obj->size; i > 0; i--) {
        obj->data[i] = obj->data[i-1];
    }
    obj->data[0] = value;
    obj->size++;
    return true;
}

bool myCircularDequeInsertLast(MyCircularDeque* obj, int value) {
    if (obj->size == obj->capacity) return false;
    obj->data[obj->size] = value;
    obj->size++;
    return true;
}

bool myCircularDequeDeleteFront(MyCircularDeque* obj) {
    if (obj->size == 0) return false;
    // Shift all elements left
    for (int i = 0; i < obj->size - 1; i++) {
        obj->data[i] = obj->data[i+1];
    }
    obj->size--;
    return true;
}

bool myCircularDequeDeleteLast(MyCircularDeque* obj) {
    if (obj->size == 0) return false;
    obj->size--;
    return true;
}

int myCircularDequeGetFront(MyCircularDeque* obj) {
    return obj->size == 0 ? -1 : obj->data[0];
}

int myCircularDequeGetRear(MyCircularDeque* obj) {
    return obj->size == 0 ? -1 : obj->data[obj->size - 1];
}

bool myCircularDequeIsEmpty(MyCircularDeque* obj) {
    return obj->size == 0;
}

bool myCircularDequeIsFull(MyCircularDeque* obj) {
    return obj->size == obj->capacity;
}

void myCircularDequeFree(MyCircularDeque* obj) {
    free(obj->data);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Front operations require shifting all n elements

✓ Linear Growth

Space Complexity

O(k)

Need array of size k to store elements

✓ Linear Space

Constraints

1 ≤ k ≤ 1000
0 ≤ value ≤ 1000
At most 2000 calls will be made to all methods combined
All values will be in the range [0, 1000]

58.2K Views

Medium-High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Array with Linear Shifts — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler