Queue Using Array - Problem

Implement a queue data structure using an array. Your implementation should support the following operations:

enqueue(item) - Add an element to the rear of the queue
dequeue() - Remove and return the front element from the queue
front() - Return the front element without removing it
isEmpty() - Check if the queue is empty
size() - Return the number of elements in the queue

You will be given a sequence of operations to perform on the queue. For each operation, you need to return the appropriate result or null if the operation is invalid (e.g., dequeue from empty queue).

Note: The queue should handle wrap-around when using a fixed-size array to maximize space efficiency.

Input & Output

Example 1 — Basic Queue Operations

$ Input: operations = [["enqueue",10],["enqueue",20],["front"],["dequeue"],["size"],["isEmpty"]]

› Output: [null,null,10,10,1,false]

💡 Note: Enqueue 10 and 20 (returns null), front returns 10, dequeue returns and removes 10, size is 1, isEmpty is false

Example 2 — Empty Queue Operations

$ Input: operations = [["isEmpty"],["dequeue"],["front"],["size"]]

› Output: [true,null,null,0]

💡 Note: Empty queue: isEmpty returns true, dequeue and front return null, size is 0

Example 3 — Mixed Operations

$ Input: operations = [["enqueue",5],["enqueue",15],["dequeue"],["enqueue",25],["front"],["size"]]

› Output: [null,null,5,null,15,2]

💡 Note: Add 5,15; remove 5; add 25; front is 15; size is 2 (elements: 15,25)

Constraints

1 ≤ operations.length ≤ 1000
Each operation is valid according to the queue interface
-10⁴ ≤ element values ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 35 M Microsoft 28 G Google 22 🍎 Apple 18

The key insight is using a circular array with front and rear pointers to eliminate expensive element shifting operations. The optimal approach uses modulo arithmetic for wrap-around, achieving O(1) time for all operations. Time: O(1) per operation, Space: O(n) for fixed array storage.

Common Approaches

✓ Circular Array Queue

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

Implement queue using a fixed-size circular array with front and rear pointers. When pointers reach the end of array, they wrap around to the beginning, eliminating the need to shift elements.

Shift Array Elements

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

Store elements in a regular array and shift all elements forward whenever dequeue is called. This approach is simple but inefficient due to the constant shifting of elements.

Circular Array Queue — Algorithm Steps

Initialize fixed-size array with front and rear pointers
Enqueue: Add element at rear position, move rear pointer forward (with wrap-around)
Dequeue: Remove element at front position, move front pointer forward (with wrap-around)
Handle wrap-around using modulo operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up circular array with front and rear pointers

Operations

Move pointers with modulo arithmetic for wrap-around

Efficiency

O(1) operations with no element shifting

Code -

solution.c — C

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

#define MAX_SIZE 1000

char* solution() {
    static char result[10000];
    strcpy(result, "[]");
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    printf("%s\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (enqueue, dequeue, front, isEmpty, size) take constant time

✓ Linear Growth

Space Complexity

O(n)

Fixed-size array to store queue elements, where n is the maximum capacity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Queue Using Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Circular Array Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler