Design Circular Queue

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

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

✓ Array with Shifting

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

Implement using a regular array where dequeue operations require shifting all remaining elements to the front. This maintains the queue order but is inefficient.

Circular Array with Two Pointers

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

Implement using a fixed-size array with two pointers (front and rear) and a count variable. Use modular arithmetic to wrap around when reaching array boundaries, avoiding element shifting.

Array with Shifting — Algorithm Steps

Use array to store elements
On enqueue: add to end
On dequeue: remove first and shift all elements left

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Array with elements [1,2,3]

Dequeue Operation

Remove first element and shift remaining left

Result

All elements moved one position left

Code -

solution.c — C

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

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

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

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return false;
    }
    for (int i = 0; i < obj->size - 1; i++) {
        obj->data[i] = obj->data[i + 1];
    }
    obj->size--;
    return true;
}

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

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

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

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

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

static char input_buffer[100000];
static char operations[1000][50];
static int values[1000][10];
static int value_counts[1000];

int parse_operations(char* line, char ops[][50]) {
    int count = 0;
    char* ptr = strchr(line, '[');
    if (!ptr) return 0;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '"') {
            ptr++;
            int len = 0;
            while (*ptr && *ptr != '"') {
                ops[count][len++] = *ptr++;
            }
            ops[count][len] = '\0';
            count++;
            if (*ptr == '"') ptr++;
        }
        ptr++;
    }
    return count;
}

int parse_values(char* line, int vals[][10], int counts[]) {
    int count = 0;
    char* ptr = strchr(line, '[');
    if (!ptr) return 0;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int val_count = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    vals[count][val_count++] = num;
                } else {
                    ptr++;
                }
            }
            counts[count] = val_count;
            count++;
            if (*ptr == ']') ptr++;
        }
        ptr++;
    }
    return count;
}

int main() {
    char line1[100000], line2[100000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int op_count = parse_operations(line1, operations);
    int val_count = parse_values(line2, values, value_counts);
    
    if (op_count == 0) {
        printf("[]\n");
        return 0;
    }
    
    MyCircularQueue* queue = myCircularQueueCreate(values[0][0]);
    
    printf("[null");
    
    for (int i = 1; i < op_count; i++) {
        printf(",");
        
        if (strcmp(operations[i], "enQueue") == 0) {
            bool result = myCircularQueueEnQueue(queue, values[i][0]);
            printf("%s", result ? "true" : "false");
        } else if (strcmp(operations[i], "deQueue") == 0) {
            bool result = myCircularQueueDeQueue(queue);
            printf("%s", result ? "true" : "false");
        } else if (strcmp(operations[i], "Front") == 0) {
            int result = myCircularQueueFront(queue);
            printf("%d", result);
        } else if (strcmp(operations[i], "Rear") == 0) {
            int result = myCircularQueueRear(queue);
            printf("%d", result);
        } else if (strcmp(operations[i], "isEmpty") == 0) {
            bool result = myCircularQueueIsEmpty(queue);
            printf("%s", result ? "true" : "false");
        } else if (strcmp(operations[i], "isFull") == 0) {
            bool result = myCircularQueueIsFull(queue);
            printf("%s", result ? "true" : "false");
        }
    }
    
    printf("]\n");
    
    myCircularQueueFree(queue);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Dequeue requires shifting n elements in worst case

✓ Linear Growth

Space Complexity

O(k)

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

Array with Shifting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler