Design Circular Queue - Practice Coding Problems

Design Circular Queue - Problem

Design and implement a circular queue data structure! A circular queue is a clever variation of the traditional queue that connects the last position back to the first position, forming a complete circle.

🎯 The Challenge: Unlike regular queues that waste space when elements are dequeued from the front, circular queues reuse that freed space efficiently. When the rear pointer reaches the end of the array, it wraps around to the beginning if there's available space.

Your Task: Implement the MyCircularQueue class with these operations:

MyCircularQueue(k) - Initialize with size k
enQueue(value) - Insert element, return true if successful
deQueue() - Remove element, return true if successful
Front() - Get front element (-1 if empty)
Rear() - Get rear element (-1 if empty)
isEmpty() - Check if queue is empty
isFull() - Check if queue is full

Note: You cannot use built-in queue data structures!

Input & Output

example_1.py — Basic Operations

$ Input: ["MyCircularQueue","enQueue","enQueue","enQueue","enQueue","Rear","isFull","deQueue","enQueue","Rear"] [[3],[1],[2],[3],[4],[],[],[],[4],[]]

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

💡 Note: Initialize queue of size 3. Add 1,2,3 successfully. Adding 4 fails (full). Rear is 3. Queue is full. Remove one element. Add 4 successfully. New rear is 4.

example_2.py — Empty Queue Operations

$ Input: ["MyCircularQueue","Front","Rear","deQueue","isEmpty","enQueue","Front"] [[2],[],[],[],[],[5],[]]

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

💡 Note: Initialize empty queue size 2. Front/Rear return -1 (empty). DeQueue fails (empty). Queue is empty. Add 5. Front is now 5.

example_3.py — Wraparound Behavior

$ Input: ["MyCircularQueue","enQueue","enQueue","deQueue","enQueue","deQueue","enQueue","Front","Rear"] [[2],[1],[2],[],[3],[],[4],[],[]]

› Output: [null,true,true,true,true,true,true,3,4]

💡 Note: Size 2 queue. Add 1,2. Remove 1. Add 3 (uses wrapped position). Remove 2. Add 4. Queue now has [3,4] with front=3, rear=4.

Visualization

Tap to expand

Understanding the Visualization

Initialize

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

EnQueue

Add element at rear position, move rear pointer clockwise

DeQueue

Move front pointer clockwise (element logically removed)

Wraparound

Pointers wrap to beginning using modulo when reaching end

Key Takeaway

🎯 Key Insight: Modular arithmetic `(index + 1) % size` creates seamless wraparound, eliminating the need for expensive array shifts while maintaining O(1) performance for all operations.

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (enQueue, deQueue, Front, Rear) execute in constant time

✓ Linear Growth

Space Complexity

O(k)

Uses array of size k+1 to store k elements with extra space for full/empty detection

✓ Linear Space

Constraints

1 ≤ k ≤ 1000
0 ≤ value ≤ 1000
At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull
All values will be in the range [0, 1000]

Asked in

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

The optimal solution uses a circular array with two pointers (front and rear) and modular arithmetic to achieve O(1) time complexity for all operations. The key insight is allocating k+1 spaces to distinguish between full and empty states, allowing the queue to wrap around efficiently without shifting elements.

Common Approaches

Approach	Time	Space	Notes
✓ Array with Shifting (Inefficient)	O(n)	O(k)	Use array and shift elements on every dequeue operation
Optimal Circular Array with Pointers	O(1)	O(k)	Use two pointers with modular arithmetic for O(1) operations

Array with Shifting (Inefficient) — Algorithm Steps

Use a regular array to store elements
Keep track of current size
For enQueue: add element at index 'size'
For deQueue: remove first element and shift all others left
Front is always at index 0, Rear at index 'size-1'

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Queue

Queue with elements [10, 20, 30] stored at indices 0, 1, 2

DeQueue Operation

Remove element 10 from front, need to shift remaining elements

After Shifting

Elements [20, 30] now at indices 0, 1 - all elements moved left

Code -

solution.c — C

typedef struct {
    int* data;
    int maxSize;
    int size;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->data = (int*)malloc(k * sizeof(int));
    obj->maxSize = k;
    obj->size = 0;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) return false;
    obj->data[obj->size] = value;
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) return false;
    // Shift all elements left by one position
    for (int i = 0; i < obj->size - 1; i++) {
        obj->data[i] = obj->data[i + 1];
    }
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    return myCircularQueueIsEmpty(obj) ? -1 : obj->data[0];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    return myCircularQueueIsEmpty(obj) ? -1 : obj->data[obj->size - 1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->maxSize;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->data);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

DeQueue operation requires shifting all n-1 remaining elements

✓ Linear Growth

Space Complexity

O(k)

Only need array of size k to store elements

✓ Linear Space

Constraints

1 ≤ k ≤ 1000
0 ≤ value ≤ 1000
At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull
All values will be in the range [0, 1000]

87.0K Views

Medium Frequency

~25 min Avg. Time

2.2K 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 Shifting (Inefficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler