Zigzag Iterator-优快云博客

本文链接：https://blog.youkuaiyun.com/iteye_17352/article/details/82641603

本文介绍了一种用于交替返回多个一维向量元素的迭代器实现方法，并提供了三种不同的方案，包括扩展至处理k个输入链表的情况。第一种方案适用于两个输入链表，而后两种方案则更通用，能够有效处理任意数量的链表输入。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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].

[分析] 三种实现方案，方案1针对原题，方案2和方案3针对扩展到k个输入链表的情况，其中方案3使用队列很巧妙, 方案2中hasNext()在仅剩一个链表时复杂度是O(k),而方案3始终是O（1）


public class ZigzagIterator {

    private int active = 0;
    private List<Iterator<Integer>> iters;
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        iters = new ArrayList<Iterator<Integer>>();
        iters.add(v1.iterator());
        iters.add(v2.iterator());
    }

    public int next() {
        active = 1 - active;
        return iters.get(1 - active).next();
    }

    public boolean hasNext() {
        if (iters.get(active).hasNext()) {
            return true;
        } else if (iters.get(1 - active).hasNext()) {
            active = 1 - active;
            return true;
        } else {
            return false;
        }
    }
}


// Method 2: 扩展至k，使用数组保存各链表的iterator
public class ZigzagIterator {

    private int total = 2;
    private int active = 0;
    private List<Iterator<Integer>> iters;
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        iters = new ArrayList<Iterator<Integer>>();
        iters.add(v1.iterator());
        iters.add(v2.iterator());
    }

    public int next() {
        int curr = active;
        active++;
        if (active == total) active = 0;
        return iters.get(curr).next();
    }

    public boolean hasNext() {
        if (iters.get(active).hasNext()) {
            return true;
        } else {
            for (int i = 1; i <= total; i++) {
                int next = (active + i) % total;
                if (iters.get(next).hasNext()) {
                    active = next;
                    return true;
                }
            }
            return false;
        }
    }
}


// Method 3
public class ZigzagIterator {

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

    public int next() {
        Iterator<Integer> active = queue.poll();
        Integer result = active.next();
        if (active.hasNext()) queue.offer(active);
        return result;
    }

    public boolean hasNext() {
        if (!queue.isEmpty()) return true;
        else return false;
    }
}