MediumArrayLinked ListDesignQueue

Design Circular Queue

1 approach, code in every language

Design a circular queue, a fixed-size FIFO buffer that reuses the space freed by dequeued elements by wrapping the tail back to the beginning of the storage. This ring layout lets you keep enqueuing into slots that earlier elements have vacated instead of wasting them.

Implement the class MyCircularQueue. The constructor sets the queue capacity to k. enQueue(value) inserts an element at the back and returns whether it succeeded. deQueue() removes an element from the front and returns whether it succeeded. Front() returns the front element or -1 if the queue is empty. Rear() returns the last element or -1 if the queue is empty. isEmpty() and isFull() report whether the queue is empty or at capacity.

Example 1

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

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

With capacity 3, the first three enQueue calls succeed and the fourth fails because the queue is full. Rear is 3 and isFull is true. After one deQueue, enQueue(4) fits and Rear becomes 4.

Example 2

Input: operations = ["MyCircularQueue", "isEmpty", "enQueue", "Front", "deQueue", "isEmpty"] args = [[2], [], [8], [], [], []]

Output: [null, true, true, 8, true, true]

A fresh queue is empty. After enQueue(8), Front is 8. Dequeuing that only element leaves the queue empty again.

Constraints

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

Fixed Array with Head Index and Count

Store elements in an array of size k, track the head position and the current element count, and compute the tail with modular arithmetic.

Loading animation…

Intuition

A circular queue is just a plain array whose indices wrap around when they run past the end. If we remember where the front sits and how many elements are stored, we can always compute the tail slot as head plus count taken modulo the capacity. Using an explicit count avoids the classic ambiguity where a full ring and an empty ring look identical. Wrapping with the modulo operator lets dequeued front slots be reused by later enqueues without ever shifting elements.

Algorithm walkthrough

1Allocate a fixed array of capacity k and initialize head to 0 and count to 0.
2isEmpty is count equal to 0, and isFull is count equal to capacity; use these as guards.
3For enQueue, if not full, write to slot (head + count) mod capacity, increment count, and report success.
4For deQueue, if not empty, advance head to (head + 1) mod capacity and decrement count, freeing the old front slot.
5Front returns the element at head, and Rear returns the element at (head + count - 1) mod capacity, each returning -1 when empty.
6Every operation is constant time because it only reads or writes a single computed index.

Implementation

class MyCircularQueue:
    def __init__(self, k: int):
        self.data = [0] * k
        self.capacity = k
        self.head = 0
        self.count = 0

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        tail = (self.head + self.count) % self.capacity
        self.data[tail] = value
        self.count += 1
        return True

    def deQueue(self) -> bool:
        if self.isEmpty():
            return False
        self.head = (self.head + 1) % self.capacity
        self.count -= 1
        return True

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        return self.data[self.head]

    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        tail = (self.head + self.count - 1) % self.capacity
        return self.data[tail]

    def isEmpty(self) -> bool:
        return self.count == 0

    def isFull(self) -> bool:
        return self.count == self.capacity

Time

O(1) for every operation, since each one only computes and touches a single index.

Space

O(k) for the fixed backing array of capacity k.

Tracking an explicit count removes the full-versus-empty ambiguity that arises when relying only on head and tail pointers.

Create a free account to see the solution

You get the step-by-step animation, the intuition and clean code in every language. Free, no credit card.

Create a free account Already have an account? Sign in

Back to Stacks & Queues

After the pattern

Now solve one you haven't seen.

Reading a pattern isn't the same as using it. The practice set has 1,194 original problems on the same techniques, each graded in your browser.

Open the practice set Start the FDE path

1,194 problems · 15,062 graded tests · free