Iterator in Stack/Queue

（一）Flatten Nested List Iterator

题目：要求用迭代器将嵌套的链表展开，如 [1,2[3,4],5] 返回[1,2,3,4,5]。要求实现函数 next() 以返回下一个展开的数字，函数hasNext() 以返回是否存在下一个需要展开的数。

           题目已定义数据类型NestedInteger中包含3个函数：isInteger()用来判断是整数还是嵌套的组合；getInteger()用来返回当前数字，若是嵌套组合则返回null；getList()将嵌套               组合用list的方式返回，若为数字则返回null;

解答：在初始化阶段将list按顺序放入栈中（使用两个栈实现）；

           hasNext()函数将栈顶嵌套组合完全展开后，判断栈是否为空；

           next()函数先调用hasNext()函数来展开栈顶嵌套组合并判断是否存在下一个元素，若存在则返回下一个数字（栈顶元素的数字）；

代码：

public class NestedIterator implements Iterator<Integer> {
    Stack <NestedInteger> stack;
    public NestedIterator(List<NestedInteger> nestedList) {
        stack = new Stack<>();
        pushListToStack(nestedList);
    }
    
    private void pushListToStack(List<NestedInteger> nestedList) {
        Stack <NestedInteger> temp = new Stack<>();
        for (NestedInteger single : nestedList) {
            temp.push(single);
        }
        
        while (!temp.isEmpty()) {
            stack.push(temp.pop());
        }
    }


    @Override
    public Integer next() {
        if (!hasNext()) {
            return null;
        }
        return stack.pop().getInteger();
    }


    @Override
    public boolean hasNext() {
        while (!stack.isEmpty() && !stack.peek().isInteger()) {
            pushListToStack(stack.pop().getList());
        }
        return !stack.isEmpty();
    }
}

（二）Binary Search Tree Iterator

https://leetcode.com/problems/binary-search-tree-iterator/description/

题目：完成一个二叉搜索树的迭代器，其中next()函数返回下一个最小值, next()和hasNext()函数要求时间复杂度为O(1)，空间复杂度为O(h)；

解答：自行写一个addAllLeft的函数()，从根节点开始把左侧所有的数依次放入栈中，初始化时即调用该函数；

           next()函数:将栈顶元素取出则为最下一个最小值，若取出的点存在右节点，则调用addAllLeft(node.right)；

代码：

public class BSTIterator {
    Stack<TreeNode> stack = new Stack<>();


    public BSTIterator(TreeNode root) {
        addAllLeft(root);
    }


    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return !stack.isEmpty();
    }


    /** @return the next smallest number */
    public int next() {
        TreeNode node = stack.pop();
        if (node.right != null) {
            addAllLeft(node.right);
        }
        return node.val;
    }
    
    private void addAllLeft(TreeNode node) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
    }
}

（三）Zigzag Iterator （AC)

https://leetcode.com/problems/zigzag-iterator/description/

题目：给定两个一维向量，以左旋右旋的形式顺序返回新的向量。如：v1 = [1, 2]    v2 = [3, 4, 5, 6]  返回 [1, 3, 2, 4, 5, 6]

解答：使用队列，在初始化时，将列表值按顺序依次添加到队列中；

代码：

public class ZigzagIterator {
    Queue<Integer> queue;
    
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        queue = new LinkedList<>();
        int index1 = 0, index2 = 0;
        
        while (index1 < v1.size() && index2 < v2.size()) {
            queue.offer(v1.get(index1++));
            queue.offer(v2.get(index2++));
        }
        while (index1 < v1.size()) {
            queue.offer(v1.get(index1++));
        }
        while (index2 < v2.size()) {
            queue.offer(v2.get(index2++));
        }  
    }


    public int next() {
        return queue.poll();
    }


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

（四）Flatten 2D Vector （AC）

https://leetcode.com/problems/flatten-2d-vector/description/

题目：将二维向量展开成一维；

解答：依次展开放入队列；

代码：

public class Vector2D implements Iterator<Integer> {
    Queue<Integer> queue;
    
    public Vector2D(List<List<Integer>> vec2d) {
        queue = new LinkedList<>();
        for (List<Integer> vec : vec2d) {
            for (int num : vec) {
                queue.offer(num);
            }
        }
    }


    @Override
    public Integer next() {
        return queue.poll();
    }


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