Circular Buffer - Problem

A circular buffer is a fixed-size data structure that uses a single, fixed-size buffer as if it were connected end-to-end. This structure is useful for buffering data streams where the oldest data is automatically overwritten when the buffer is full.

Implement a CircularBuffer class with the following operations:

add(value): Add an element to the buffer. If the buffer is full, overwrite the oldest element.
read(): Read and remove the oldest element from the buffer. Return null if the buffer is empty.

Your implementation should handle the buffer's full and empty states correctly and use modulo arithmetic for efficient wraparound.

Input & Output

Example 1 — Basic Operations

$ Input: capacity = 3, operations = [["add",1],["add",2],["read"],["add",3],["add",4],["read"],["read"]]

› Output: [1,2,3]

💡 Note: Add 1,2 → buffer=[1,2,null]. Read returns 1 → buffer=[null,2,null]. Add 3,4 → buffer=[4,2,3] (4 overwrites position 0). Read returns 2, then 3.

Example 2 — Empty Buffer

$ Input: capacity = 2, operations = [["read"],["add",5],["read"],["read"]]

› Output: [5]

💡 Note: Read from empty buffer returns nothing. Add 5 → buffer=[5,null]. Read returns 5. Read from empty buffer again returns nothing.

Example 3 — Overwrite Pattern

$ Input: capacity = 2, operations = [["add",1],["add",2],["add",3],["add",4],["read"],["read"]]

› Output: [3,4]

💡 Note: Add 1,2 fills buffer. Add 3 overwrites 1, Add 4 overwrites 2. Buffer=[3,4]. Read returns 3, then 4.

Constraints

1 ≤ capacity ≤ 1000
1 ≤ operations.length ≤ 1000
operations[i] is either ["add", value] or ["read"]
-1000 ≤ value ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 22 M Microsoft 18 🍎 Apple 12

The key insight is using two pointers (head and tail) with modulo arithmetic to efficiently manage the circular nature of the buffer. The optimal approach maintains O(1) time complexity for both add and read operations by avoiding linear searches. Time: O(1) per operation, Space: O(n) for the buffer.

Common Approaches

✓ Linear Search for Oldest Element

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

For each add/read operation, scan the entire buffer to find the appropriate position. Track insertion order with timestamps or counters.

Two Pointers with Modulo Arithmetic

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

Maintain head pointer for reads and tail pointer for writes. Use modulo arithmetic to handle wraparound efficiently.

Linear Search for Oldest Element — Algorithm Steps

For add: scan buffer to find oldest element position if full
For read: scan buffer to find oldest element to remove
Use timestamps or counters to track insertion order

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Operation

Scan entire buffer to find oldest element when full

Read Operation

Scan entire buffer to find oldest element to remove

Result

O(n) time per operation due to linear search

Code -

solution.c — C

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

typedef struct {
    int capacity;
    int* buffer;
    int* timestamps;
    int* occupied;
    int counter;
    int size;
} CircularBuffer;

CircularBuffer* createBuffer(int capacity) {
    CircularBuffer* cb = malloc(sizeof(CircularBuffer));
    cb->capacity = capacity;
    cb->buffer = malloc(capacity * sizeof(int));
    cb->timestamps = malloc(capacity * sizeof(int));
    cb->occupied = calloc(capacity, sizeof(int));
    cb->counter = 0;
    cb->size = 0;
    return cb;
}

void add(CircularBuffer* cb, int value) {
    if (cb->size < cb->capacity) {
        for (int i = 0; i < cb->capacity; i++) {
            if (!cb->occupied[i]) {
                cb->buffer[i] = value;
                cb->timestamps[i] = cb->counter++;
                cb->occupied[i] = 1;
                cb->size++;
                return;
            }
        }
    } else {
        int oldestIdx = 0;
        for (int i = 1; i < cb->capacity; i++) {
            if (cb->timestamps[i] < cb->timestamps[oldestIdx]) {
                oldestIdx = i;
            }
        }
        cb->buffer[oldestIdx] = value;
        cb->timestamps[oldestIdx] = cb->counter++;
    }
}

int readBuffer(CircularBuffer* cb) {
    if (cb->size == 0) return -1;
    int oldestIdx = 0;
    for (int i = 1; i < cb->capacity; i++) {
        if (cb->occupied[i] && cb->timestamps[i] < cb->timestamps[oldestIdx]) {
            oldestIdx = i;
        }
    }
    int value = cb->buffer[oldestIdx];
    cb->occupied[oldestIdx] = 0;
    cb->size--;
    return value;
}

int main() {
    int capacity;
    scanf("%d", &capacity);
    
    CircularBuffer* cb = createBuffer(capacity);
    
    // Parse operations and execute
    printf("[]");
    
    free(cb->buffer);
    free(cb->timestamps);
    free(cb->occupied);
    free(cb);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each add/read operation requires scanning entire buffer to find oldest element

✓ Linear Growth

Space Complexity

O(n)

Buffer array plus additional tracking for timestamps or counters

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Circular Buffer - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search for Oldest Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler