design-设计iterator

iterator：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。每次调用next()，只返回下一个元素，且“记住”这个位置，下回调用next()，还要接着从这里resume。

题目	简介
281. Zigzag Iterator	遍历多个list
284. Peeking Iterator	遍历list
604. Design Compressed String Iterator	遍历解压缩之后的string
900. RLE Iterator	遍历压缩版string
341. Flatten Nested List Iterator	用stack来存nested list
173. Binary Search Tree Iterator	用stack来存“一路向左”

281. Zigzag Iterator

Input:
v1 = [1,2]
v2 = [3,4,5,6]
Output: [1,3,2,4,5,6]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,3,2,4,5,6].

这个并不是真的实现一个iterator，而是每个list都有自己的iterator，Zigzag Iterator只是搞了一个queue，来轮流使用v1,v2的自己的iterator而已。

public class ZigzagIterator {

    Queue<Iterator> q;
    
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        q = new LinkedList<>();
        if (!v1.isEmpty()) {q.offer(v1.iterator());}
        if (!v2.isEmpty()) {q.offer(v2.iterator());}
    }

    public int next() {
        //take an iterator from queue
        Iterator curIter = q.poll();
        int result = (Integer)curIter.next();
        //put curIter back to queue if not used up
        if (curIter.hasNext()) {
            q.offer(curIter);
        }
        return result;
    }

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

follow-up: 把两个list的zigzag拓展到k个list，cyclic。
Input:
[1,2,3]
[4,5,6,7]
[8,9]
Output: [1,4,8,2,5,9,3,6,7].

基本不需要额外修改代码，就可以用作k个list的情况。（改下初始化即可）

284. Peeking Iterator

给一个list: [1,2,3]，有next()和hasNext()方法，实现一个PeekingIterator。即peek() operation。只展示下一个元素，不真的遍历到那个元素without advancing the iterator。（类似于peek()和poll()的区别）

这个题是实现一个真正的iterator了。基本思路就是cache the next element。在类内部设一个变量next，来缓存将要遍历到的下一个元素。

这种iterator可以想象成一个黑盒子，每次按一下按钮才出来一个，再另外的元素是无从知晓的。于是若想知道下一个元素peek()，一定是通过advance到下一个元素才行。而我们又不希望调用peek()很多次之后，指针自己跑到特前面去了（其实并不应该advance）。那怎么办呢？就 [1,2,3]我们当前在1，实际上黑盒子内部的指针已经到了3，用一个cache来缓存2，这样每次调用peek()的时候，就根本不用动指针，只是把cache里的值2返回给user而已，调用多少次peek()就返回多少次cache值。

class PeekingIterator implements Iterator < Integer>，是PeekingIterator类来实现Iterator接口，这个接口对传入元素的类型有要求，必须是Integer。我们的PeekingIterator类内部有自己的iterator，起名也叫iterator吧，在constructor中，把外面传进来的iterator赋值给我们内部的: this.iterator = iterator;

（下面这个代码是参考大米中的大米的，然而依然有error，貌似是系统问题）

class PeekingIterator implements Iterator<Integer> {
    
    Iterator<Integer> iterator;
    Integer next = null;//cache下一个element
    
	public PeekingIterator(Iterator<Integer> iterator) {
	    this.iterator = iterator;//初始化指针在1
        if(iterator.hasNext()){
            next = iterator.next();//next=1,指针挪到2(指针在2是理想的初始化位置)
        }
	}
	
	public Integer peek() {
        return next;
	}
	
	@Override
	public Integer next() {
        Integer result = next;//next是返回当前记录的这个next，即1
        next = (iterator.hasNext()) ? iterator.next() : null;//挪指针之后，next就变为2了
	    return result;
	}
	
	@Override
	public boolean hasNext() {
	    return (next != null);
	}
}

follow-up: generic, work with all types, not just integer

integer有什么特殊的吗？这个还没想清楚

604. Design Compressed String Iterator

StringIterator iterator = new StringIterator(“L1e2t1C1o1d1e1”);
iterator.next(); // return ‘L’ 依次返回“未经压缩”的字符串的各个字母。
iterator.next(); // return ‘e’
iterator.next(); // return ‘e’
iterator.next(); // return ‘t’

前面281和284是list上的iterator，java的list本身具备内置的iterator，281就是使用iterator而已（没有真正实现），284就是实现Iterator< Integer>这个接口，其本身就有next()方法，list的各个元素是不可知的，需要靠next()来获知。

而604和900都是实现压缩字符串的iterator，string的各个字母都是已知的，就很简单了，基本思路是用"index"来记录每次调用next()到的位置。

这个题就把每个字母和其后面的数字分为一组，“L1”, “e2”, “t1”, “C1”, “o1”, “d1”, “e1”。调用next()的时候，分两种情况：

1. 正要新开始一个组
2. 在处理某个组的中间

class StringIterator {
    
    String compressedString;
    int index;
    int curCnt;
    Character curChar;

    public StringIterator(String compressedString) {
        this.compressedString = compressedString;
        index = 0;
        curCnt = 0;
        curChar = null;
    }
    
    public char next() {
        if (curCnt == 0) {//开始一个新的group"e2"(<curChar,curCnt>作为一个group)
            if (index >= compressedString.length()) {return ' ';}//注意这里下标超出范围的处理！
            //step 1:get curChar
            curChar = compressedString.charAt(index);
            index++;
            //step 2:get curCnt
            while (index < compressedString.length() && compressedString.charAt(index) >= '0' && compressedString.charAt(index) <= '9') {
                curCnt = curCnt * 10 + compressedString.charAt(index) - '0';//别忘了减'0'
                index++;
            }
        }
        curCnt--;//在处理a given group的中间
        return curChar;
    }
    
    public boolean hasNext() {
        return ( (index < compressedString.length()) || (curCnt != 0) );
    }
}

900. RLE Iterator

实现一个run-length encoded sequence上的iterator
For example, we start with A = [3,8,0,9,2,5], which is a run-length encoding of the sequence [8,8,8,5,5]

这个和上面604刚好是反的。给了<curCnt, curNum>，让你恢复原本比较长的串。这个Iterator增加了一次next()走多步的功能。于是拿到“走n步”的指示，关键就是要locate到组。A = [3,8,0,9,2,5]，找n能走到[3, 0, 2]的哪里。

这里的index是A的下标，而不是展开后的[8,8,8,5,5]的下标。

每次调用next()，直接在n上减来计数，把index挪到正确位置上，即：当前组，比如“3，8”。中间跳过的那些组们就不用搭理了，A也无需修改，反正以后也用不到了。而“当前组”，说明是这次需要print的，若此时n没用完，还要记得留到下次调用next()还有用，当前组的元素还剩多少个，直接在A上更新。

class RLEIterator {
    
    int[] A;
    int index;

    public RLEIterator(int[] A) {
        this.A = A;
        index = 0;
    }
    
    public int next(int n) {
        //通过直接在n上减来计数，把index挪到正确位置上
        while(index < A.length && n > A[index]){
            n = n - A[index];//A[index]:当前组在n中实际占的位置数
            index += 2;//每组在A中占两个位置
        }
        //若index越界
        if(index >= A.length){
            return -1;
        }
        //curCnt还剩多少个，直接在A上更新
        A[index] = A[index] - n;
        return A[index + 1];//curNumber是curCnt的下一个
    }
}

341和173还没写完，因为要准备面试，有空再回来写这俩。

341. Flatten Nested List Iterator

Input: [[1,1],2,[1,1]] 把nested list拍平。
Output: [1,1,2,1,1]

341和下面的173都是用stack的，和上面的区别就是，这里的数据结构不是线性的。281,284都是list, 604,900是string，都是线性的。这里341是nested list，有点类似（多叉）树状的结构，173直接就是二叉树。

这种结构的问题在于，各个元素在内存中不是连续的，是要通过left,right指针来得到下一个元素的。（其实281,284都是list，在内存中也不是连续的，所以才需要借助内置的next()来实现）。于是没办法用index来记录遍历到哪个节点了。那记录了遍历到的节点指针呢？？

普通的遍历不能暂停，于是只能用另外的思路。

还有个答案说，an iterator shouldn’t copy the entire data
此处有点麻烦回头再写

173. Binary Search Tree Iterator

173在“tree-inorder中序遍历”那篇写过了。普通的遍历不能中间暂停。

class BSTIterator { //in-order
    
    Stack<TreeNode> stk = new Stack<>();

    public BSTIterator(TreeNode root) {
        pushAll(root);
    }
    
    public int next() {
        TreeNode cur = stk.pop();
        pushAll(cur.right);
        return cur.val;
    }
    
    public boolean hasNext() {
        return !stk.isEmpty();
    }
    
    private void pushAll(TreeNode node) {
        while (node != null) {
            stk.push(node);
            node = node.left;
        }
    }
}