Is Peeking Iterator easy or hard?

Peeking Iterator is usually classified as a medium difficulty problem. The logic is simple once you realize you must cache the next element, but many candidates initially break iterator semantics by advancing the iterator during peek().

Peeking Iterator Python/Java solution

In Python or Java, wrap the existing iterator and store the next value in a variable during construction. peek() returns the stored value, next() returns it and fetches the next element from the iterator, and hasNext() checks whether the buffer is empty.

How to solve Peeking Iterator in O(1)?

Store the next element from the iterator in a buffer during initialization. peek() simply returns this buffered value. next() returns the buffer and then advances the iterator to refresh the stored value. This ensures constant-time operations without modifying the original collection.

What is the best approach for Peeking Iterator?

The best approach is maintaining a cached next element (look-ahead buffer). Store the upcoming value from the underlying iterator so peek() returns it without advancing the iterator. When next() is called, return the cached value and fetch the next one. All operations run in O(1) time with O(1) extra space.

Is Peeking Iterator asked at Google/Amazon/Meta?

Peeking Iterator is a common design-style interview question and has appeared in interviews at companies like Google, Amazon, and Meta. It tests understanding of iterator abstraction, state management, and API design rather than heavy algorithms.

What data structure is used in Peeking Iterator?

The solution primarily uses an iterator abstraction with a single cached variable. The underlying data often comes from an array or list, but the key design pattern is a look-ahead buffer that stores the next element.

What is the time complexity of Peeking Iterator?

Each operation—peek(), next(), and hasNext()—runs in O(1) time. The design only stores one additional variable containing the next element, so the space complexity is O(1). The iterator is traversed exactly once.

Description Hints 4 Solution Video 4:05

284. Peeking Iterator

Medium61.9% acceptance3 companies

Design an iterator that supports the peek operation on an existing iterator in addition to the hasNext and the 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.

Example 1:

Input
["PeekingIterator", "next", "peek", "next", "next", "hasNext"]
[[[1, 2, 3]], [], [], [], [], []]
Output
[null, 1, 2, 2, 3, false]

Explanation
PeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]
peekingIterator.next();    // return 1, the pointer moves to the next element [1,2,3].
peekingIterator.peek();    // return 2, the pointer does not move [1,2,3].
peekingIterator.next();    // return 2, the pointer moves to the next element [1,2,3]
peekingIterator.next();    // return 3, the pointer moves to the next element [1,2,3]
peekingIterator.hasNext(); // return False

Constraints:

1 <= nums.length <= 1000
1 <= nums[i] <= 1000
All the calls to next and peek are valid.
At most 1000 calls will be made to next, hasNext, and peek.

Follow up: How would you extend your design to be generic and work with all types, not just integer?

Asked at 3 companies

Yahoo Apple

Google

Topics

Hints open one at a time

Hint 1

Think of "looking ahead". You want to cache the next element.

Hint 2

Is one variable sufficient? Why or why not?

Hint 3

Test your design with call order of peek() before next() vs next() before peek().

Hint 4

For a clean implementation, check out Google's guava library source code.

4:05

Still stuck?Read 3 approaches, or watch a walkthrough.

Open solution

Similar problems

Binary Search Tree IteratorMedium Flatten 2D VectorMedium Zigzag IteratorMedium

LanguageLoading editor…

1# Below is the interface for Iterator, which is already defined for you.
2#
3# class Iterator:
4#     def __init__(self, nums):
5#         """
6#         Initializes an iterator object to the beginning of a list.
7#         :type nums: List[int]
8#         """
9#
10#     def hasNext(self):
11#         """
12#         Returns true if the iteration has more elements.
13#         :rtype: bool
14#         """
15#
16#     def next(self):
17#         """
18#         Returns the next element in the iteration.
19#         :rtype: int
20#         """
21 
22class PeekingIterator:
23    def __init__(self, iterator):
24        """
25        Initialize your data structure here.
26        :type iterator: Iterator
27        """
28        
29 
30    def peek(self):
31        """
32        Returns the next element in the iteration without advancing the iterator.
33        :rtype: int
34        """
35        
36 
37    def next(self):
38        """
39        :rtype: int
40        """
41        
42 
43    def hasNext(self):
44        """
45        :rtype: bool
46        """
47        
48 
49# Your PeekingIterator object will be instantiated and called as such:
50# iter = PeekingIterator(Iterator(nums))
51# while iter.hasNext():
52#     val = iter.peek()   # Get the next element but not advance the iterator.
53#     iter.next()         # Should return the same value as [val].

Starter codePython 3Spaces: 4

Examples

Case 1

Input

["PeekingIterator","next","peek","next","next","hasNext"]
[[[1,2,3]],[],[],[],[],[]]

Your code is saved on this device.Solution