refactor 281

Author: fishercoder1534

README.md

@@ -361,7 +361,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |284|[Peeking Iterator](https://leetcode.com/problems/peeking-iterator/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_284.java)| O(n)|O(n) | Medium| Design
 |283|[Move Zeroes](https://leetcode.com/problems/move-zeroes/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_283.java)| O(n)|O(1) | Easy| 
 |282|[Expression Add Operators](https://leetcode.com/problems/expression-add-operators/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_282.java)| O(?)|O(?) | Hard|
-|281|[Zigzag Iterator](https://leetcode.com/problems/zigzag-iterator/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_281.java)| O(n)|O(n) | Medium|
+|281|[Zigzag Iterator](https://leetcode.com/problems/zigzag-iterator/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_281.java)| O(1)|O(k) | Medium|
 |280|[Wiggle Sort](https://leetcode.com/problems/wiggle-sort/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_280.java)| O(n)|O(1) | Medium|
 |279|[Perfect Squares](https://leetcode.com/problems/perfect-squares/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_279.java)| O(n)|O(1) | Medium| 
 |278|[First Bad Version](https://leetcode.com/problems/first-bad-version/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_278.java)| O(logn)|O(1) | Easy| Binary Search

src/main/java/com/fishercoder/solutions/_281.java

@@ -1,9 +1,13 @@
 package com.fishercoder.solutions;
 
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Queue;
 
 /**
+ * 281. Zigzag Iterator
+ *
  * Given two 1d vectors, implement an iterator to return their elements alternately.
 
  For example, given two 1d vectors:
@@ -15,7 +19,8 @@
  Follow up: What if you are given k 1d vectors? How well can your code be extended to such cases?
 
  Clarification for the follow up question - Update (2015-09-18):
- The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". For example, given the following input:
+ The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases.
+ If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". For example, given the following input:
 
  [1,2,3]
  [4,5,6,7]
@@ -24,26 +29,61 @@
  */
 public class _281 {
 
-    private Iterator<Integer> i;
-    private Iterator<Integer> j;
-    private Iterator<Integer> tmp;
+    public static class Solution1 {
+        public static class ZigzagIterator {
+            private Iterator<Integer> i;
+            private Iterator<Integer> j;
+            private Iterator<Integer> tmp;
 
-    public _281(List<Integer> v1, List<Integer> v2) {
-        i = v2.iterator();
-        j = v1.iterator();
-    }
+            public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
+                i = v2.iterator();
+                j = v1.iterator();
+            }
+
+            public int next() {
+                if (j.hasNext()) {
+                    tmp = j;
+                    j = i;
+                    i = tmp;
+                }
+                return i.next();
+            }
 
-    public int next() {
-        if (j.hasNext()) {
-            tmp = j;
-            j = i;
-            i = tmp;
+            public boolean hasNext() {
+                return i.hasNext() || j.hasNext();
+            }
         }
-        return i.next();
     }
 
-    public boolean hasNext() {
-        return i.hasNext() || j.hasNext();
-    }
+    public static class Solution2 {
+        public static class ZigzagIterator {
+
+            Queue<Iterator<Integer>> queue;
 
+            public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
+                queue = new LinkedList<>();
+                if (v1 != null && !v1.isEmpty()) {
+                    Iterator<Integer> iterator1 = v1.iterator();
+                    queue.offer(iterator1);
+                }
+                if (v2 != null && !v2.isEmpty()) {
+                    Iterator<Integer> iterator2 = v2.iterator();
+                    queue.offer(iterator2);
+                }
+            }
+
+            public boolean hasNext() {
+                return !queue.isEmpty();
+            }
+
+            public int next() {
+                Iterator<Integer> iterator = queue.poll();
+                int next = iterator.next();
+                if (iterator.hasNext()) {
+                    queue.offer(iterator);
+                }
+                return next;
+            }
+        }
+    }
 }