leetcode 341 Flatten Nested List Iterator 以及其余Iterator合集

Iterator其实就是一个单链表，没法回头看。java里不少数据结构都有这个接口，使用时须要initalize,获得一个iterator.
调用next()返回的是一个object, 指向的是下一个未访问过的部分。
hasnext()返回的是boolean, 表示是否走到告终尾。

284 Peeking Iterator

class PeekingIterator implements Iterator<Integer> {
    Iterator<Integer> iter;
    Integer next = null;    // 起到的就是缓存做用，由于next()调用以后立刻就走到下一个object了。
    
    public PeekingIterator(Iterator<Integer> iterator) {
        // initialize any member here.
        iter = iterator;
        if(iter.hasNext()){
            next = iter.next();
        }
    }

    // Returns the next element in the iteration without advancing the iterator.
    public Integer peek() {
        return next;
    }

    // hasNext() and next() should behave the same as in the Iterator interface.
    // Override them if needed.
    @Override
    public Integer next() {
        Integer res = next;
        next = iter.hasNext() ? iter.next() : null;
        return res;
    }

    @Override
    public boolean hasNext() {
        return next != null;
    }
}

281 Zigzag Iterator

public class ZigzagIterator {
    Queue<Iterator> list;
    
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        list = new LinkedList<Iterator>();
        if(!v1.isEmpty()) list.add(v1.iterator());
        if(!v2.isEmpty()) list.add(v2.iterator());
        // 若是给的是k个list, List<List<Integer>> vs, 只须要把全部v1,v1...vk生成iterator放到q里
        // for(List<Integer> v: List<List<Integer>>) if(!v.isEmpty()) list.add(v.iterator());
    }

    public int next() {
        Iterator iter = list.poll();
        int res = (Integer) iter.next();
        if(iter.hasNext()) list.offer(iter);
        return res;
    }

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

Zigzag Iterator这个题目和merge k sorted list很像，design twitter用到的就是merge k sorted list的思想加上OOD，会另写一篇。

173 BST Iterator

戳这里，BST inorder小专题。
bst iterator

341 Flatten Nested List Iterator

题目的意思定义了一个特殊的数据结构，用括号造成不少层，按从左到右的顺序输出。
括号是个强提示，要把括号里的东西拆开还保持原来的顺序，就须要用stack处理。
[1,[4,[6]]] 存到stack里，变成|[4,[6]], [1]|
栈顶调用isInteger()，返回true, 就要getInteger()输出。
若是调用isInteger()，返回false, 用getList()获得和最初的输入相同的list,作相同的步骤存入stack.
不断拆开NestedInteger, 获得结果。
这题就是给的API有点多，须要读懂题意，而后再拆开获得结果。stack思想就是来自括号，后面也会跟进stack的专题.

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class NestedIterator implements Iterator<Integer> {
    ArrayDeque<NestedInteger> stk;
    
    public NestedIterator(List<NestedInteger> nestedList) {
        stk = new ArrayDeque<NestedInteger>();
        for(int i = nestedList.size()-1; i >= 0; i--){
            stk.addLast(nestedList.get(i));
        }
    }

    @Override
    public Integer next() {
        return stk.pollLast().getInteger();
    }

    @Override
    public boolean hasNext() {
        while(!stk.isEmpty()){
            NestedInteger cur = stk.peekLast();
            if(cur.isInteger()){
                return true;
            }
            List<NestedInteger> list = stk.pollLast().getList();
            for(int i=list.size()-1; i>=0; i--){
                stk.addLast(list.get(i));
            }
        }
        return false;
    }
}```