Design Circular Queue

Intuitionthe array is storage, while the indices describe the queue

A queue removes the oldest item and adds new items after the newest one. In a normal array, repeatedly removing from the front would leave unused cells at the beginning, and shifting the remaining values would make deletion expensive. A circular queue avoids both problems by treating the last array cell as adjacent to the first, so a pointer can wrap around and reuse released cells.

Use front for the index of the current first item and rear for the next position where an item will be inserted. The number of stored items is kept separately in size. That count is the important third piece of state: without it, front equal to rear could mean either an empty queue or a full queue.

Approachkeep one invariant for every operation

1. 1Allocate an array of capacity k, set front and rear to 0, and set size to 0, because the queue starts empty and rear must initially identify the first insertion slot.
2. 2Declare the queue empty when size is 0 and full when size equals capacity, because comparing front and rear alone cannot distinguish those two states.
3. 3For enQueue, reject the operation when the queue is full, because writing at rear would overwrite an item that has not been removed.
4. 4Write the new value at arr[rear], advance rear with (rear + 1) % capacity, and increase size, because the next insertion must use the following circular slot while the new value joins the back.
5. 5For deQueue, reject the operation when the queue is empty, because there is no front item to remove and front must not move.
6. 6When deQueue succeeds, advance front with (front + 1) % capacity and decrease size, because the old front is discarded and the next stored item becomes the new front.
7. 7Return arr[front] from Front and arr[(rear - 1 + capacity) % capacity] from Rear when the queue is non-empty, because front names the first item while rear names the slot after the last item.
8. 8Process the operation list by constructing the queue once, forwarding each command to the matching method, and recording its result as a string, because the required output includes the constructor's null marker as well as every operation result.

Complexityconstant work per queue operation

Annotated solutionC++ · array-backed ring buffer plus operation replay

#include <string>
#include <vector>

using namespace std;

class MyCircularQueue {
    int* arr;
    int front;
    int rear;
    int size;
    int capacity;

public:
    MyCircularQueue(int k) : arr(new int[k]), front(0), rear(0), size(0), capacity(k) {}

    ~MyCircularQueue() {
        delete[] arr;
    }

    bool enQueue(int value) {
        if (isFull()) return false;

        arr[rear] = value;
        rear = (rear + 1) % capacity;
        size++;
        return true;
    }

    bool deQueue() {
        if (isEmpty()) return false;

        front = (front + 1) % capacity;
        size--;
        return true;
    }

    int Front() {
        if (isEmpty()) return -1;
        return arr[front];
    }

    int Rear() {
        if (isEmpty()) return -1;
        return arr[(rear - 1 + capacity) % capacity];
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity;
    }
};

class Solution {
public:
    vector<string> execute(vector<string> ops, vector<vector<int>> vals) {
        vector<string> result;
        MyCircularQueue* queue = nullptr;

        for (int i = 0; i < static_cast<int>(ops.size()); i++) {
            if (ops[i] == "MyCircularQueue") {
                queue = new MyCircularQueue(vals[i][0]);
                result.push_back("null");
            } else if (ops[i] == "enQueue") {
                result.push_back(queue->enQueue(vals[i][0]) ? "true" : "false");
            } else if (ops[i] == "deQueue") {
                result.push_back(queue->deQueue() ? "true" : "false");
            } else if (ops[i] == "Front") {
                result.push_back(to_string(queue->Front()));
            } else if (ops[i] == "Rear") {
                result.push_back(to_string(queue->Rear()));
            } else if (ops[i] == "isEmpty") {
                result.push_back(queue->isEmpty() ? "true" : "false");
            } else if (ops[i] == "isFull") {
                result.push_back(queue->isFull() ? "true" : "false");
            }
        }

        delete queue;
        return result;
    }
};

The key placement choice is that rear always means the next insertion position. This makes enQueue direct, but it means Rear must look one position backward. Adding capacity before taking the modulo keeps that backward step non-negative when rear is 0. The destructor releases the manually allocated array after execute finishes, so the queue does not leave its storage behind.

Common mistakesthe two index conventions that most often break the ring