Peeking Iterator - Practice Coding Problems

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

Key Insight: Buffer the next element to peek without advancing the iterator

Understanding the Visualization

Input

Iterator with [1,2,3] and operations to perform

Process

Peek shows next element without moving, next advances

Output

Results array based on operations performed

Key Takeaway

🎯 Key Insight: Use a buffer to cache the next element, enabling peek operations in O(1) time without affecting iterator state

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

Approach	Time	Space	Notes
✓ Store All Elements	O(1)	O(n)	Convert iterator to array and maintain position index
Buffer Next Element	O(1)	O(1)	Cache only the next element in a buffer variable

Store All Elements — Algorithm Steps

Store all iterator elements in array
Use index to track current position
Implement operations using array indexing

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Convert iterator [1,2,3] to array, index=0

Operations

Use index to peek/next without re-reading

Result

Return values based on operations

Code -

solution.c — C

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

typedef struct {
    int* elements;
    int size;
    int index;
} PeekingIterator;

PeekingIterator* createPeekingIterator(int* nums, int size) {
    PeekingIterator* pi = (PeekingIterator*)malloc(sizeof(PeekingIterator));
    pi->elements = (int*)malloc(size * sizeof(int));
    pi->size = size;
    pi->index = 0;
    
    for (int i = 0; i < size; i++) {
        pi->elements[i] = nums[i];
    }
    
    return pi;
}

int peek(PeekingIterator* pi) {
    return pi->elements[pi->index];
}

int next(PeekingIterator* pi) {
    return pi->elements[pi->index++];
}

bool hasNext(PeekingIterator* pi) {
    return pi->index < pi->size;
}

char* solution(int* nums, int numsSize, char operations[][10], int opsSize) {
    PeekingIterator* pi = createPeekingIterator(nums, numsSize);
    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->elements);
    free(pi);
    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)

All operations access array by index in constant time

✓ Linear Growth

Space Complexity

O(n)

Store all n elements in array during initialization

⚡ Linearithmic 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

Store All Elements — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler