Welcome to Subscribe On Youtube

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;
            return toReturn;
        }
    
        @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):
            """
            Initialize your data structure here.
            :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):
        """
        Initialize your data structure here.
        :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
    }
    

All Problems

All Solutions