Peeking Iterator

                                            
class PeekingIterator : public Iterator {
private:
    bool peeked;
    int peek_val;
public:
    PeekingIterator(const vector<int>& nums) : Iterator(nums), peeked(false) {}

    int peek() {
        if (!peeked) {
            peek_val = Iterator::next();
            peeked = true;
        }
        return peek_val;
    }

    int next() {
        if (peeked) {
            peeked = false;
            return peek_val;
        }
        return Iterator::next();
    }

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

                                            
// 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 Integer nextElement;

    public PeekingIterator(Iterator<Integer> iterator) {
        this.iterator = iterator;
        if (iterator.hasNext()) {
            nextElement = iterator.next();
        }
    }

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

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

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

                                            
class PeekingIterator:
    def __init__(self, iterator):
        self.iterator = iterator
        self.peeked_value = None

    def peek(self):
        if self.peeked_value is None:
            self.peeked_value = self.iterator.next()
        return self.peeked_value

    def next(self):
        if self.peeked_value is not None:
            result = self.peeked_value
            self.peeked_value = None
            return result
        return self.iterator.next()

    def hasNext(self):
        return self.peeked_value is not None or self.iterator.hasNext()

                                            
/*
 *  struct Iterator {
 *      // Returns true if the iteration has more elements.
 *      bool (*hasNext)();
 *
 *      // Returns the next element in the iteration.
 *      int (*next)();
 *  };
 */
struct PeekingIterator {
    struct Iterator* iter;
    int next_val;
    bool has_next;
};

struct PeekingIterator* Constructor(struct Iterator* iter) {
    struct PeekingIterator* peek_iter = (struct PeekingIterator*)malloc(sizeof(struct PeekingIterator));
    peek_iter->iter = iter;
    peek_iter->has_next = iter->hasNext();
    if (peek_iter->has_next) {
        peek_iter->next_val = iter->next();
    }
    return peek_iter;
}

int peek(struct PeekingIterator* obj) {
    return obj->next_val;
}

int next(struct PeekingIterator* obj) {
    int res = obj->next_val;
    obj->has_next = obj->iter->hasNext();
    if (obj->has_next) {
        obj->next_val = obj->iter->next();
    }
    return res;
}

bool hasNext(struct PeekingIterator* obj) {
    return obj->has_next;
}

To solve this coding challenge, we need to implement a custom iterator class called

PeekingIterator

that wraps an existing iterator and adds a

peek()

method. This method allows us to view the next element without consuming it. We'll also need to implement the existing methods

next()

and

hasNext()

such that they work seamlessly with our new

peek()

functionality.

Explanation

Let's break down the problem and the functionalities we need to implement:

Initialization : We need to initialize the
PeekingIterator

with an existing iterator. We'll also need a variable to store the peeked value.
Peek Operation : The
peek()

method will return the next element without advancing the iterator. If no element has been peeked yet, it will retrieve it from the wrapped iterator and store it for future use.
Next Operation : The
next()

method will return the next element from the iterator. If an element has been peeked (using the
peek()

method), it should return that element and reset the peeked value.
HasNext Operation : The
hasNext()

method will check if there are any elements left in the iterator. It should account for both the peeked value and the state of the wrapped iterator.

Step-by-Step Explanation/Detailed Steps in Pseudocode

Step 1: Initialization

Initialize the
PeekingIterator

with the given iterator.
Set the
peeked_value

to
None

indicating that no value has been peeked yet.

Step 2: Peek Method

Check if there is a
peeked_value

already stored. If yes, return it.
If no
peeked_value

is stored, get the next value from the iterator, store it in
peeked_value

, and then return it.

Step 3: Next Method

Check if there is a
peeked_value

. If yes, return it and reset
peeked_value

to
None

.
If no
peeked_value

is stored, directly return the next value from the iterator.

Step 4: HasNext Method

Check if there is a
peeked_value

which would mean there is at least one element left. If yes, return
True

.
If
peeked_value

is
None

, return the result of
hasNext

on the wrapped iterator.

Pseudocode with Comments

                                            
# PeekingIterator class to extend standard iterator functionalities
class PeekingIterator:
    # Constructor method to initialize the class with an existing iterator
    method __init__(iterator):
        # Store the provided iterator
        this.iterator = iterator
        # Initialize the peeked_value to None
        this.peeked_value = None

    # Method to peek the next element without moving the iterator
    method peek() -> int:
        # If there is no peeked value yet
        if this.peeked_value is None:
            # Retrieve the next value from the iterator and store in peeked_value
            this.peeked_value = this.iterator.next()
        # Return the peeked value
        return this.peeked_value

    # Method to get the next element and move the iterator
    method next() -> int:
        # If there is a peeked value
        if this.peeked_value is not None:
            # Store the peeked value in a variable to return it
            result = this.peeked_value
            # Reset peeked_value to None
            this.peeked_value = None
            # Return the previous peeked value
            return result
        # If there is no peeked value, return the next value from the iterator
        return this.iterator.next()

    # Method to check if there are more elements in the iterator
    method hasNext() -> bool:
        # Return True if there is a peeked value or if the iterator has more elements
        return this.peeked_value is not None or this.iterator.hasNext()

By following this pseudocode, we can implement the

PeekingIterator

class that satisfies the requirements laid out in the problem description. This class will be capable of peeking at the next element without consuming it, moving to the next element, and checking if more elements are available in the underlying iterator.