[LeetCode] 281. Zigzag Iterator

Given two 1d vectors, implement an iterator to return their elements alternately.
For example, given two 1d vectors:
v1 = [1, 2]
v2 = [3, 4, 5, 6]
By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1, 3, 2, 4, 5, 6].
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:
[1,2,3]
[4,5,6,7]
[8,9]
It should return [1,4,8,2,5,9,3,6,7].

Thought process:
Combine two lists into one zigzag list in the constructor.

Solution 1 (iterator):

 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
29
30
31
32
public class ZigzagIterator {
    private Queue<Iterator> queue;

    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        queue = new LinkedList<>();
        if (v1.size() > 0) {
            queue.offer(v1.iterator());
        }
        if (v2.size() > 0) {
            queue.offer(v2.iterator());
        }
    }

    public int next() {
        Iterator it = queue.poll();
        int next = (Integer) it.next();
        if (it.hasNext()) {
            queue.offer(it);
        }
        return next;
    }

    public boolean hasNext() {
        return !queue.isEmpty();
    }
}

/**
 * Your ZigzagIterator object will be instantiated and called as such:
 * ZigzagIterator i = new ZigzagIterator(v1, v2);
 * while (i.hasNext()) v[f()] = i.next();
 */

Solution 2:
 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
29
30
31
32
33
34
35
36
37
38
39
40
public class ZigzagIterator {
    private int pointer;
    private List<Integer> zigzag;

    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        pointer = 0;
        zigzag = new ArrayList<>();
        int i = 0;
        
        while (true) {
            int size = zigzag.size();
            if (i < v1.size()) {
                zigzag.add(v1.get(i));
            }
            if (i < v2.size()) {
                zigzag.add(v2.get(i));
            }
            if (zigzag.size() == size) {
                break;
            }
            i++;
        }
    }

    public int next() {
        int next = zigzag.get(pointer);
        pointer++;
        return next;
    }

    public boolean hasNext() {
        return pointer < zigzag.size();
    }
}

/**
 * Your ZigzagIterator object will be instantiated and called as such:
 * ZigzagIterator i = new ZigzagIterator(v1, v2);
 * while (i.hasNext()) v[f()] = i.next();
 */

Time complexity:
  1. Constructor: O(n).
  2. next(); O(1).
  3. hasNext(): O(1).

Comments

Popular posts from this blog

[LeetCode] 269. Alien Dictionary

[HackerRank] Roads and Libraries

[LeetCode] 631. Design Excel Sum Formula