284. Peeking Iterator

1. Description

Design an iterator that supports the peek operation on a list in addition to the hasNext and the next operations.
Implement the PeekingIterator class:

• PeekingIterator(int[] nums) Initializes the object with the given integer array nums.
• int next() Returns the next element in the array and moves the pointer to the next element.
• bool hasNext() Returns true if there are still elements in the array.
• int peek() Returns the next element in the array without moving the pointer.

2. Example

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

3. Note

• 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.

4. Follow Up

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

5. Solutions

Iterator Wrapper

n = m_nums.size()
Time complexity: O(1)
Space complexity: O(1)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// I don't understand this question
class PeekingIterator : public Iterator {
public:
    // PeekingIterator(const vector<int>& nums) : Iterator(nums) {
    PeekingIterator(const vector<int>& i_nums) : Iterator(i_nums) {
        // Initialize any member here.
        // **DO NOT** save a copy of nums and manipulate it directly.
        // You should only use the Iterator interface methods.
    }

    // Returns the next element in the iteration without advancing the iterator.
    int peek() {
        if (hasNext()) {
            Iterator it(*this);
            return it.next();
        }
        return 0;
    }

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

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