Design Circular Queue - Practice Coding Problems

Design Circular Queue - Problem

Design your implementation of the circular queue. The circular queue is a linear data structure in which operations are performed based on FIFO (First In First Out) principle, and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".

One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.

Implement the MyCircularQueue class:

MyCircularQueue(k) - Initializes the object with the size of the queue to be k
boolean enQueue(int value) - Inserts an element into the circular queue. Return true if the operation is successful
boolean deQueue() - Deletes an element from the circular queue. Return true if the operation is successful
int Front() - Gets the front item from the queue. If the queue is empty, return -1
int Rear() - Gets the last item from the queue. If the queue is empty, return -1
boolean isEmpty() - Checks whether the circular queue is empty or not
boolean isFull() - Checks whether the circular queue is full or not

You must solve the problem without using the built-in queue data structure in your programming language.

Input & Output

Example 1 — Basic Queue Operations

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

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

💡 Note: Create queue of size 3, add 1,2,3 successfully, adding 4 fails (full), rear is 3, queue is full, dequeue removes 1, now can add 4, new rear is 4

Example 2 — Empty Queue Checks

$ Input: operations = ["MyCircularQueue", "isEmpty", "Front", "Rear"], values = [[2], [], [], []]

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

💡 Note: Create empty queue of size 2, isEmpty returns true, Front and Rear return -1 for empty queue

Example 3 — Wrap Around Behavior

$ Input: operations = ["MyCircularQueue", "enQueue", "enQueue", "deQueue", "enQueue", "deQueue", "enQueue", "Front", "Rear"], values = [[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 → remove 2 → add 4. Shows circular reuse of positions

Constraints

1 ≤ k ≤ 1000
0 ≤ value ≤ 1000
At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull

Visualization

Tap to expand

Understanding the Visualization

Input

Sequence of queue operations and their parameters

Process

Execute operations using circular array with front/rear pointers

Output

Return results of each operation

Key Takeaway

🎯 Key Insight: Modular arithmetic enables efficient circular indexing without element shifting

Asked in

a Amazon 45 M Microsoft 35 G Google 30 f Facebook 25

The key insight is to use a fixed-size array with front and rear pointers that wrap around using modular arithmetic. This avoids costly element shifting operations. Best approach uses circular array with two pointers achieving O(1) for all operations. Time: O(1), Space: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Circular Array with Two Pointers	O(1)	O(k)	Use fixed-size array with front and rear pointers, wrapping around with modular arithmetic
Array with Shifting	O(n)	O(k)	Use regular array and shift elements on dequeue operations

Circular Array with Two Pointers — Algorithm Steps

Create fixed array of size k+1
Use front and rear pointers
Use modular arithmetic for circular indexing
Track count to distinguish full vs empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Empty circular array with front=0, rear=-1

EnQueue Operations

Add elements, rear pointer moves clockwise

DeQueue Operations

Remove elements, front pointer moves clockwise

Code -

solution.c — C

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

typedef struct {
    int* data;
    int capacity;
    int front;
    int rear;
    int count;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->data = (int*)malloc(k * sizeof(int));
    obj->capacity = k;
    obj->front = 0;
    obj->rear = -1;
    obj->count = 0;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (obj->count == obj->capacity) {
        return false;
    }
    obj->rear = (obj->rear + 1) % obj->capacity;
    obj->data[obj->rear] = value;
    obj->count++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->count == 0) {
        return false;
    }
    obj->front = (obj->front + 1) % obj->capacity;
    obj->count--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->count == 0) {
        return -1;
    }
    return obj->data[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (obj->count == 0) {
        return -1;
    }
    return obj->data[obj->rear];
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->count == obj->capacity;
}

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

int main() {
    printf("[null,true,true,true,false,3,true,true,true,false,4,true]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are constant time with pointer updates

✓ Linear Growth

Space Complexity

O(k)

Fixed array of size k to store queue elements

✓ Linear Space

142.0K Views

Medium Frequency

~25 min Avg. Time

1.6K 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

Circular Array with Two Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler