Question

Formatted question description: https://leetcode.ca/all/284.html

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?

Algorithm

You can define a variable preFetch to save the next value, use a bool variable to mark whether the next value is saved, and then call some of the original member functions.

Code

• import java.util.Iterator;

class PeekingIterator implements Iterator<Integer> {
private Integer preFetch = null;
private Iterator<Integer> iterator;

public PeekingIterator(Iterator<Integer> iterator) {
// initialize any member here.
this.iterator = iterator;
if (this.iterator.hasNext())
preFetch = this.iterator.next();
}

// Returns the preFetch element in the iteration without advancing the iterator.
public Integer peek() {
return preFetch;
}

// hasNext() and preFetch() should behave the same as in the Iterator interface.
// Override them if needed.
@Override
public Integer next() {
Integer toReturn = preFetch;
preFetch = iterator.hasNext() ? iterator.next() : null;
}

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

/////////////////////////////////

// I used 2 flags to indicate if it's end of an iterator
// but, Integer can be noll, but int cannot be null. So, set preFetch to be null will solve the problem
public class Peeking_Iterator {

// Java Iterator interface reference:
// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
class PeekingIterator implements Iterator<Integer> {

int preFetch;
Iterator<Integer> iterator;
boolean isIteratorEmpty;
boolean isLastPrefetchPopped;

public PeekingIterator(Iterator<Integer> iterator) {

this.iterator = iterator;

// initialize any member here.
if (this.iterator.hasNext()) {
preFetch = this.iterator.next();
} else {
isIteratorEmpty = true;
isLastPrefetchPopped = true;
}
}

// Returns the preFetch element in the iteration without advancing the iterator.
public Integer peek() {

if (isIteratorEmpty && isLastPrefetchPopped) {
// cannot peek, throw some exception here
return null;
} else {
return preFetch;
}
}

// hasNext() and preFetch() should behave the same as in the Iterator interface.
// Override them if needed.
@Override
public Integer next() {

if (isIteratorEmpty && isLastPrefetchPopped) {
// cannot peek, throw some exception here
return null;
}

int toReturn = preFetch;

if (this.iterator.hasNext()) {
preFetch = this.iterator.next();
} else {
isIteratorEmpty = true;
isLastPrefetchPopped= true;
}

return preFetch;
}

@Override
public boolean hasNext() {
if (isIteratorEmpty && isLastPrefetchPopped) {
return false;
} else {
return true;
}
}
}

}

############

// Java Iterator interface reference:
// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html

class PeekingIterator implements Iterator<Integer> {
private Iterator<Integer> iterator;
private boolean hasPeeked;
private Integer peekedElement;

public PeekingIterator(Iterator<Integer> iterator) {
// initialize any member here.
this.iterator = iterator;
}

// Returns the next element in the iteration without advancing the iterator.
public Integer peek() {
if (!hasPeeked) {
peekedElement = iterator.next();
hasPeeked = true;
}
return peekedElement;
}

// hasNext() and next() should behave the same as in the Iterator interface.
// Override them if needed.
@Override
public Integer next() {
if (!hasPeeked) {
return iterator.next();
}
Integer result = peekedElement;
hasPeeked = false;
peekedElement = null;
return result;
}

@Override
public boolean hasNext() {
return hasPeeked || iterator.hasNext();
}
}

• # Below is the interface for Iterator, which is already defined for you.
#
# class Iterator:
#     def __init__(self, nums):
#         """
#         Initializes an iterator object to the beginning of a list.
#         :type nums: List[int]
#         """
#
#     def hasNext(self):
#         """
#         Returns true if the iteration has more elements.
#         :rtype: bool
#         """
#
#     def next(self):
#         """
#         Returns the next element in the iteration.
#         :rtype: int
#         """

class PeekingIterator:
def __init__(self, iterator):
"""
:type iterator: Iterator
"""
self.iterator = iterator
self.has_peeked = False
self.peeked_element = None

def peek(self):
"""
Returns the next element in the iteration without advancing the iterator.
:rtype: int
"""
if not self.has_peeked:
self.peeked_element = self.iterator.next()
self.has_peeked = True
return self.peeked_element

def next(self):
"""
:rtype: int
"""
if not self.has_peeked:
return self.iterator.next()
result = self.peeked_element
self.has_peeked = False
self.peeked_element = None
return result

def hasNext(self):
"""
:rtype: bool
"""
return self.has_peeked or self.iterator.hasNext()

# Your PeekingIterator object will be instantiated and called as such:
# iter = PeekingIterator(Iterator(nums))
# while iter.hasNext():
#     val = iter.peek()   # Get the next element but not advance the iterator.
#     iter.next()         # Should return the same value as [val].

############

# Below is the interface for Iterator, which is already defined for you.
#
# class Iterator(object):
#     def __init__(self, nums):
#         """
#         Initializes an iterator object to the beginning of a list.
#         :type nums: List[int]
#         """
#
#     def hasNext(self):
#         """
#         Returns true if the iteration has more elements.
#         :rtype: bool
#         """
#
#     def next(self):
#         """
#         Returns the next element in the iteration.
#         :rtype: int
#         """

class PeekingIterator(object):
def __init__(self, iterator):
"""
:type iterator: Iterator
"""
self.iter = iterator
self.nextElem = None

def peek(self):
"""
Returns the next element in the iteration without advancing the iterator.
:rtype: int
"""
if self.nextElem:
return self.nextElem
if self.iter.hasNext():
self.nextElem = self.iter.next()
return self.nextElem

def next(self):
"""
:rtype: int
"""
ret = self.nextElem

if self.nextElem:
self.nextElem = None
return ret

return self.iter.next()

def hasNext(self):
"""
:rtype: bool
"""
return (self.nextElem is not None) or self.iter.hasNext()

# Your PeekingIterator object will be instantiated and called as such:
# iter = PeekingIterator(Iterator(nums))
# while iter.hasNext():
#     val = iter.peek()   # Get the next element but not advance the iterator.
#     iter.next()         # Should return the same value as [val].


• /*
* Below is the interface for Iterator, which is already defined for you.
* **DO NOT** modify the interface for Iterator.
*
*  class Iterator {
*		struct Data;
* 		Data* data;
*  public:
*		Iterator(const vector<int>& nums);
* 		Iterator(const Iterator& iter);
*
* 		// Returns the next element in the iteration.
*		int next();
*
*		// Returns true if the iteration has more elements.
*		bool hasNext() const;
*	};
*/

class PeekingIterator : public Iterator {
public:
PeekingIterator(const vector<int>& nums)
: Iterator(nums) {
// Initialize any member here.
// **DO NOT** save a copy of nums and manipulate it directly.
// You should only use the Iterator interface methods.
hasPeeked = false;
}

// Returns the next element in the iteration without advancing the iterator.
int peek() {
if (!hasPeeked) {
peekedElement = Iterator::next();
hasPeeked = true;
}
return peekedElement;
}

// hasNext() and next() should behave the same as in the Iterator interface.
// Override them if needed.
int next() {
if (!hasPeeked) return Iterator::next();
hasPeeked = false;
return peekedElement;
}

bool hasNext() const {
return hasPeeked || Iterator::hasNext();
}

private:
bool hasPeeked;
int peekedElement;
};

• /*   Below is the interface for Iterator, which is already defined for you.
*
*   type Iterator struct {
*
*   }
*
*   func (this *Iterator) hasNext() bool {
*		// Returns true if the iteration has more elements.
*   }
*
*   func (this *Iterator) next() int {
*		// Returns the next element in the iteration.
*   }
*/

type PeekingIterator struct {
iter          *Iterator
hasPeeked     bool
peekedElement int
}

func Constructor(iter *Iterator) *PeekingIterator {
return &PeekingIterator{iter, iter.hasNext(), iter.next()}
}

func (this *PeekingIterator) hasNext() bool {
return this.hasPeeked || this.iter.hasNext()
}

func (this *PeekingIterator) next() int {
if !this.hasPeeked {
return this.iter.next()
}
this.hasPeeked = false
return this.peekedElement
}

func (this *PeekingIterator) peek() int {
if !this.hasPeeked {
this.peekedElement = this.iter.next()
this.hasPeeked = true
}
return this.peekedElement
}