## DEV Community is a community of 871,688 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

seanpgallivan

Posted on

# Solution: Peeking Iterator

This is part of a series of Leetcode solution explanations (index). If you liked this solution or found it useful, please like this post and/or upvote my solution post on Leetcode's forums.

#### Leetcode Problem #284 (Medium): Peeking Iterator

Description:

Given an Iterator class interface with methods: `next()` and `hasNext()`, design and implement a PeekingIterator that support the `peek()` operation -- it essentially `peek()` at the element that will be returned by the next call to `next()`.

Examples:

Example:
Input: ["PeekingIterator","next","peek","next","next","hasNext"]
[[[1,2,3]],[],[],[],[],[]]
Output: [null,1,2,2,3,false]
Explanation Assume that the iterator is initialized to the beginning of the list: [1,2,3].

Call next() gets you 1, the first element in the list.
Now you call peek() and it returns 2, the next element.
Calling next() after that still return 2.
You call next() the final time and it returns 3, the last element.
Calling hasNext() after that should return false.

Idea:

The trick here is realizing that you're not building the class from scratch. Instead, you're building a class that is constructed from another class instance.

Our new class will do the same things that the original class does, except that it will store the next value separately, so that we can peek at it without it being removed. The only challenging thing at this point is to make sure that the next function checks to make sure if there actually is a next element before updating the stored value.

Javascript Code:

The best result for the code below is 72ms / 39.0MB (beats 93% / 83%).

``````class PeekingIterator {
constructor(iterator) {
this.iterator = iterator
this.nextVal = this.iterator.hasNext() ? this.iterator.next() : null
};

peek() {
return this.nextVal
};

next() {
let nextVal = this.nextVal
this.nextVal = this.iterator.hasNext() ? this.iterator.next() : null
return nextVal
};

hasNext() {
return !!this.nextVal
};
};
``````

Python Code:

The best result for the code below is 20ms / 14.2MB (beats 99% / 100%).

``````class PeekingIterator:
def __init__(self, iterator):
self.iterator = iterator
self.nextVal = self.iterator.next() if self.iterator.hasNext() else None

def peek(self):
return self.nextVal

def next(self):
nextVal = self.nextVal
self.nextVal = self.iterator.next() if self.iterator.hasNext() else None
return nextVal

def hasNext(self):
return bool(self.nextVal)
``````

Java Code:

The best result for the code below is 4ms / 38.6MB (beats 94% / 96%).

``````class PeekingIterator implements Iterator<Integer> {
Iterator<Integer> iter;
Integer nextVal;

public PeekingIterator(Iterator<Integer> iterator) {
iter = iterator;
nextVal = iter.hasNext() ? iter.next() : null;
}

public Integer peek() {
return nextVal;
}

@Override
public Integer next() {
Integer oldNext = nextVal;
nextVal = iter.hasNext() ? iter.next() : null;
return oldNext;
}

@Override
public boolean hasNext() {
return (nextVal != null);
}
}
``````

C++ Code:

The best result for the code below is 0ms / 7.3MB (beats 100% / 94%).

``````class PeekingIterator : public Iterator {
public:
int nextVal;

PeekingIterator(const vector<int>& nums) : Iterator(nums) {
nextVal = Iterator::hasNext() ? Iterator::next() : NULL;
}

int peek() {
return nextVal;
}

int next() {
int oldNext = nextVal;
nextVal = Iterator::hasNext() ? Iterator::next() : NULL;
return oldNext;
}

bool hasNext() const {
return (nextVal != NULL);
}
};
``````