Sponsored
Sponsored
In this approach, we use an internal buffer variable to store the next element of the iterator. The key idea is to always keep the next element ready in this buffer when operations like `peek` are called. The `peek` method can return this buffered value, and the `next` method will return the buffered value while simultaneously updating the buffer with the new next element from the iterator.
Time Complexity: O(1) for all operations.
Space Complexity: O(1), as we only store single elements.
1import java.util.Iterator;
2
3class PeekingIterator implements Iterator<Integer> {
4 private Iterator<Integer> iterator;
5 private Integer nextElement;
6
7 public PeekingIterator(Iterator<Integer> iterator) {
8 this.iterator = iterator;
9 if (iterator.hasNext()) {
10 nextElement = iterator.next();
11 }
12 }
13
14 public Integer peek() {
15 return nextElement;
16 }
17
18 @Override
19 public Integer next() {
20 Integer current = nextElement;
21 nextElement = iterator.hasNext() ? iterator.next() : null;
22 return current;
23 }
24
25 @Override
26 public boolean hasNext() {
27 return nextElement != null;
28 }
29}The Java solution implements the Iterator interface and keeps a private variable `nextElement` to cache the next element. The constructor initializes the `nextElement` by fetching the first element from the iterator if available. Similar to Python, `peek` returns the cached value, and `next` updates the cache with the next iterator value. `hasNext` checks if `nextElement` is null.
This approach leverages the iterator's facility by explicitly controlling its movement and caching the result for future references. It reads the next element so that `peek` can access it but avoids advancing through a list prematurely. Operations are efficient with constant time complexity for each of `peek`, `next`, and `hasNext`.
Time Complexity: O(1) for all operations.
Space Complexity: O(1).
1#include <vector>
2using namespace std;
3
4class PeekingIterator : public Iterator {
5 int nextElement;
bool hasPeeked;
public:
PeekingIterator(const vector<int>& nums) : Iterator(nums), hasPeeked(false) {}
int peek() {
if (!hasPeeked) {
nextElement = Iterator::next();
hasPeeked = true;
}
return nextElement;
}
int next() {
if (!hasPeeked) return Iterator::next();
hasPeeked = false;
return nextElement;
}
bool hasNext() const {
return hasPeeked || Iterator::hasNext();
}
};The C++ solution leverages inheritance from the `Iterator` class, and the `hasPeeked` flag is used to track whether the next element has already been fetched. When `peek()` is called, it sets `nextElement` via `Iterator::next()` and `hasPeeked` to `true`. The `next()` function returns `nextElement` if `hasPeeked` is true and resets the flag. `hasNext()` is straightforward, returning `true` if either `hasPeeked` is true or `Iterator::hasNext()` is true.