Peeking Iterator

Peeking Iterator - Problem

Design an iterator that supports the peek operation on an existing iterator in addition to the hasNext and next operations.

Implement the PeekingIterator class:

PeekingIterator(Iterator<int> nums) Initializes the object with the given integer iterator iterator.
int next() Returns the next element in the array and moves the pointer to the next element.
boolean hasNext() Returns true if there are still elements in the array.
int peek() Returns the next element in the array without moving the pointer.

Note: Each language may have a different implementation of the constructor and Iterator, but they all support the int next() and boolean hasNext() functions.

Input & Output

Example 1 — Basic Operations

$ Input: nums = [1,2,3], operations = ["next", "peek", "next", "next", "hasNext"]

› Output: [1, 2, 2, 3, false]

💡 Note: next() returns 1 and advances. peek() returns 2 without advancing. next() returns 2 and advances. next() returns 3 and advances. hasNext() returns false as no more elements.

Example 2 — Multiple Peeks

$ Input: nums = [1,2], operations = ["peek", "peek", "next", "hasNext"]

› Output: [1, 1, 1, true]

💡 Note: peek() returns 1 without advancing (called twice). next() returns 1 and advances. hasNext() returns true as element 2 remains.

Example 3 — Empty Check

$ Input: nums = [1], operations = ["next", "hasNext", "peek"]

› Output: [1, false, null]

💡 Note: next() returns 1 and advances. hasNext() returns false. peek() on empty iterator behavior varies by implementation.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
At most 1000 calls will be made to next, hasNext, and peek

Visualization

Tap to expand

Asked in

G Google 23 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to cache the next element in a buffer variable to enable peek operations without advancing the underlying iterator. The optimal approach uses O(1) space by storing only one element ahead. Time: O(1), Space: O(1)

Common Approaches

✓ Buffer Next Element

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

Use a buffer to store the next element when peek() is called. This avoids storing all elements upfront while still providing O(1) peek operations.

Store All Elements

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

Read all elements from the iterator into an array during initialization. Use an index to track current position for next(), hasNext(), and peek() operations.

Buffer Next Element — Algorithm Steps

Initialize with buffer empty
On peek: fill buffer if empty, return buffer
On next: return buffer if filled, else get from iterator

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Buffer stores first element: buffer=1

Peek

Return buffer value without advancing

Return buffer, refill from iterator

Code -

solution.c — C

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

typedef struct {
    int* nums;
    int size;
    int index;
} Iterator;

typedef struct {
    Iterator* iterator;
    int buffer;
    bool hasBuffer;
} PeekingIterator;

Iterator* createIterator(int* nums, int size) {
    Iterator* it = (Iterator*)malloc(sizeof(Iterator));
    it->nums = nums;
    it->size = size;
    it->index = 0;
    return it;
}

int iteratorNext(Iterator* it) {
    return it->nums[it->index++];
}

bool iteratorHasNext(Iterator* it) {
    return it->index < it->size;
}

PeekingIterator* createPeekingIterator(Iterator* iterator) {
    PeekingIterator* pi = (PeekingIterator*)malloc(sizeof(PeekingIterator));
    pi->iterator = iterator;
    pi->hasBuffer = false;
    if (iteratorHasNext(iterator)) {
        pi->buffer = iteratorNext(iterator);
        pi->hasBuffer = true;
    }
    return pi;
}

int peek(PeekingIterator* pi) {
    return pi->buffer;
}

int next(PeekingIterator* pi) {
    int result = pi->buffer;
    if (iteratorHasNext(pi->iterator)) {
        pi->buffer = iteratorNext(pi->iterator);
    } else {
        pi->hasBuffer = false;
    }
    return result;
}

bool hasNext(PeekingIterator* pi) {
    return pi->hasBuffer;
}

char* solution(int* nums, int numsSize, char operations[][10], int opsSize) {
    Iterator* iterator = createIterator(nums, numsSize);
    PeekingIterator* pi = createPeekingIterator(iterator);
    char* result = (char*)malloc(1000 * sizeof(char));
    strcpy(result, "[");
    
    for (int i = 0; i < opsSize; i++) {
        if (i > 0) strcat(result, ",");
        
        if (strcmp(operations[i], "next") == 0) {
            char temp[20];
            sprintf(temp, "%d", next(pi));
            strcat(result, temp);
        } else if (strcmp(operations[i], "peek") == 0) {
            char temp[20];
            sprintf(temp, "%d", peek(pi));
            strcat(result, temp);
        } else if (strcmp(operations[i], "hasNext") == 0) {
            strcat(result, hasNext(pi) ? "true" : "false");
        }
    }
    
    strcat(result, "]");
    free(pi);
    free(iterator);
    return result;
}

int main() {
    int nums[100], numsSize = 0;
    char operations[100][10];
    int opsSize = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse nums array
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    
    // Parse operations array
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end) {
        start++;
        *end = '\0';
        
        token = strtok(start, ",");
        while (token != NULL) {
            // Remove quotes and spaces
            while (*token == ' ' || *token == '"') token++;
            char* endToken = token + strlen(token) - 1;
            while (*endToken == ' ' || *endToken == '"') *endToken-- = '\0';
            
            strcpy(operations[opsSize++], token);
            token = strtok(NULL, ",");
        }
    }
    
    char* result = solution(nums, numsSize, operations, opsSize);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation either returns cached value or makes one iterator call

✓ Linear Growth

Space Complexity

O(1)

Only stores one buffer element plus state variables

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

876 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

Buffer Next Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler