New Problem "Peeking Iterator"

Hao Chen · Hao Chen · commit d6483610970a · 2015-11-10T09:25:03.000+08:00
diff --git a/README.md b/README.md
@@ -14,6 +14,7 @@ LeetCode
 |290|[Word Pattern](https://leetcode.com/problems/word-pattern/) | [C++](./algorithms/cpp/wordPattern/WordPattern.cpp)|Easy|
 |287|[Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number/)  | [C++](./algorithms/cpp/findTheDuplicateNumber/findTheDuplicateNumber.cpp)|Hard|
 |285|[Inorder Successor in BST](https://leetcode.com/problems/inorder-successor-in-bst/) &hearts; | [Java](./algorithms/java/src/inorderSuccessorInBST/inorderSuccessorInBST.java)|Medium|
+|284|[Peeking Iterator](https://leetcode.com/problems/peeking-iterator/)  | [C++](./algorithms/cpp/peekingIterator/PeekingIterator.cpp)|Medium|
 |283|[Move Zeroes](https://leetcode.com/problems/move-zeroes/)  | [C++](./algorithms/cpp/moveZeroes/moveZeroes.cpp)|Easy|
 |279|[Perfect Squares](https://leetcode.com/problems/perfect-squares/) | [C++](./algorithms/cpp/perfectSquares/PerfectSquares.cpp)|Medium|
 |278|[First Bad Version](https://leetcode.com/problems/first-bad-version/)| [C++](./algorithms/cpp/firstBadVersion/FirstBadVersion.cpp), [Java](./algorithms/java/src/firstBadVersion/firstBadVersion.java)|Easy|
diff --git a/algorithms/cpp/peekingIterator/PeekingIterator.cpp b/algorithms/cpp/peekingIterator/PeekingIterator.cpp
@@ -0,0 +1,88 @@
+// Source : https://leetcode.com/problems/peeking-iterator/
+// Author : Hao Chen
+// Date   : 2015-11-10
+
+/*************************************************************************************** 
+ *
+ * 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().
+ * 
+ * Here is an example. 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.
+ * 
+ *   Think of "looking ahead". You want to cache the next element.
+ *   Is one variable sufficient? Why or why not?
+ *   Test your design with call order of peek() before next() vs next() before peek().
+ *   For a clean implementation, check out Google's guava library source code.
+ * 
+ * Follow up: How would you extend your design to be generic and work with all types, 
+ * not just integer?
+ * 
+ * Credits:Special thanks to @porker2008 for adding this problem and creating all test 
+ * cases.
+ *               
+ ***************************************************************************************/
+
+// 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);
+    virtual ~Iterator();
+    // Returns the next element in the iteration.
+    int next();
+    // Returns true if the iteration has more elements.
+    bool hasNext() const;
+};
+
+
+class PeekingIterator : public Iterator {
+private:
+    bool m_hasNext;
+    int m_next;
+    
+    void takeNext() {
+        m_hasNext = Iterator::hasNext();
+        if (m_hasNext) {
+            m_next = Iterator::next();
+        }  
+    }
+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.
+        takeNext();
+    }
+
+    // Returns the next element in the iteration without advancing the iterator.
+    int peek() {
+        return m_next;
+    }
+
+    // hasNext() and next() should behave the same as in the Iterator interface.
+    // Override them if needed.
+    int next() {
+        int temp = m_next;
+        takeNext();
+        return temp;
+        
+    }
+
+    bool hasNext() const {
+        return m_hasNext;
+    }
+};
+
