Design Circular Deque

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).

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]

Visualization

Tap to expand

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

✓ Array with Linear Shifts

⏱️ Time: O(n) Space: O(k)

This naive approach uses a simple array and shifts all elements whenever we insert or delete from the front. While conceptually simple, it's inefficient for a deque that needs frequent front operations.

Circular Array with Two Pointers (Optimal)

⏱️ Time: O(1) Space: O(k)

The optimal approach uses a circular array with two pointers (front and rear) and modular arithmetic to wrap around. This achieves O(1) time complexity for all operations by treating the linear array as if it were circular.

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>
#include <string.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);
}

static char operations[2000][20];
static int values[2000][10];
static int valueCounts[2000];

int main() {
    char line[10000];
    
    // Read operations
    fgets(line, sizeof(line), stdin);
    int opCount = 0;
    char* token = line;
    char* end = line + strlen(line);
    
    while (token < end) {
        char* comma = strchr(token, ',');
        if (comma == NULL) comma = end - 1;
        
        int len = comma - token;
        strncpy(operations[opCount], token, len);
        operations[opCount][len] = '\0';
        opCount++;
        
        token = comma + 1;
        if (token >= end) break;
    }
    
    // Read values
    fgets(line, sizeof(line), stdin);
    
    // Parse values array
    char* p = line + 1; // Skip first [
    int valueIndex = 0;
    
    while (*p && *p != '\n' && valueIndex < opCount) {
        if (*p == '[') {
            p++;
            valueCounts[valueIndex] = 0;
            
            while (*p && *p != ']') {
                if (*p >= '0' && *p <= '9') {
                    values[valueIndex][valueCounts[valueIndex]] = strtol(p, &p, 10);
                    valueCounts[valueIndex]++;
                } else {
                    p++;
                }
            }
            if (*p == ']') p++;
            valueIndex++;
        } else {
            p++;
        }
    }
    
    // Execute operations
    printf("[");
    MyCircularDeque* deque = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "MyCircularDeque") == 0) {
            deque = myCircularDequeCreate(values[i][0]);
            printf("null");
        } else if (strcmp(operations[i], "insertFront") == 0) {
            printf("%s", myCircularDequeInsertFront(deque, values[i][0]) ? "true" : "false");
        } else if (strcmp(operations[i], "insertLast") == 0) {
            printf("%s", myCircularDequeInsertLast(deque, values[i][0]) ? "true" : "false");
        } else if (strcmp(operations[i], "deleteFront") == 0) {
            printf("%s", myCircularDequeDeleteFront(deque) ? "true" : "false");
        } else if (strcmp(operations[i], "deleteLast") == 0) {
            printf("%s", myCircularDequeDeleteLast(deque) ? "true" : "false");
        } else if (strcmp(operations[i], "getFront") == 0) {
            printf("%d", myCircularDequeGetFront(deque));
        } else if (strcmp(operations[i], "getRear") == 0) {
            printf("%d", myCircularDequeGetRear(deque));
        } else if (strcmp(operations[i], "isEmpty") == 0) {
            printf("%s", myCircularDequeIsEmpty(deque) ? "true" : "false");
        } else if (strcmp(operations[i], "isFull") == 0) {
            printf("%s", myCircularDequeIsFull(deque) ? "true" : "false");
        }
    }
    printf("]\n");
    
    if (deque) myCircularDequeFree(deque);
    return 0;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Array with Linear Shifts — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler