小彩笔的痛苦刷题日记 ——扁平化嵌套列表迭代器

题目：
给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。

示例 1:

输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。
示例 2:

输入: [1,[4,[6]]]
输出: [1,4,6]
解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。

力扣官方题解一：N叉树

• 在列表内存放的有可能是整数，也有可能是列表，嵌套的列表中也有可能存放的是列表，逐层嵌套
• 可以想到这是一个树一样的结构，借用labuladong在他的题解中所画的图，可以看到，比如输入是[[1,1],2,[1,1]]结构，有如下树状结构：
  

public class NestedIterator implements Iterator<Integer> {
    private List<Integer> ret;     // 遍历这个列表，将列表中所有的数存放在一个新的列表
    private Iterator<Integer> cur; // 遍历新列表，打印出新列表

    public NestedIterator(List<NestedInteger> nestedList) {
        ret = new ArrayList<Integer>();
        dfs(nestedList);  // 深度搜索这个树
        // 上面进行结束后，ret中已经存放了遍历原本列表生成的一个只存放整数的列表
         
        cur = ret.Iterator(); //调用Iterator这个接口，本题对这个接口的以下两个功能进行了重写
    }

    @Override
    public Integer next() { // 去cur所指向的下一个位置
        return cur.next;
    }

    @Override
    public boolean hasNext() { //看是否还有后节点
        return cur.hasNext();
        
    }

    public void dfs(List<NestedInteger> nestedList){
        for(NestedInteger nest : nestedList){ //nest遍历当前列表中的每个元素
            if(nest.isInteger){ // 如果是整数，说明是叶子节点
                ret.add(nest.getInteger()) // 将当前整数放入结果列表
            }else{  // 如果是列表，说明不是叶子节点
                dfs(nest.getList()) // 迭代当前列表
            }
        }
    }
}

• 看完官方题解，我是不理解官方题解中调用Iterator是做什么的，最后是怎那么打印的，后来我注意到原题的注释下面有一段话和代码：Your NestedIterator object will be instantiated and called as such:

NestedIterator i = new NestedIterator(nestedList);
while (i.hasNext()) v[f()] = i.next();

• 实例化我倒是明白，可是后面这个循环的v[f()]是啥意思…我傻了，没见过
• 我将语言换成Python，原来这个while的语句意思是while i.hasNext(): v.append(i.next())，如果i有next的话，将i.next()加入v列表中…行吧，算是理解了。
• 就目前来看的话NestedIterator结构应该就是一个N叉树，刚好labuladong大佬也写出了N叉树的实现代码，我就直接粘过来了（复制粘贴可真爽）

public class NestedInteger{
	private Integer val;
	private List<NestedfInteger> list;
	// 两个构造函数
	// 是整数时
	public NestedInteger(Integer val){
		this.val = val;
		this.list = null;
	}
	// 是列表时
	public NestedInteger(List<NestedInteger> list){
		this.list = list;
		this.val = null;
	}
	// 如果其中存的是一个整数，则返回true，否则返回false
	public boolean isInteger(){
		return val !=null;
	}
	// 如果其中存的是一个整数，则返回这个整数，否则返回null
	public Integer getInteger(){
		return this.val;
	}
	// 如果其中存的是一个列表，则返回这个列表，否则返回Null
	public List<NestedInteger> getList(){
		return this.list;
	}
}

解法二：栈

• 官方题解的栈用法…我没看懂，不过负雪明烛大佬的题解我是看懂了，应该差不多吧…大概
• 之前在迭代的时候，是把当前的list中的所有元素都放进新的list中，这种方法是先获取了所有的结果，然后用迭代器遍历所有结果
• 迭代器最好是能一边迭代，一边获取当前的结果，而不是提前初始化好
• 递归的方法就是，在遇到一个嵌套的子list时，立即处理该list，直至全部展开
• 栈是先进后出的，所以要先逆序将这个列表中的各个元素放进栈中
• 处理流程分为两步：
  ①在构造函数中应该初始化，把当前列表的各个元素（不用摊平）逆序放入栈中。
  ②在 hasNext() 方法中，访问（不弹出）栈顶元素，判断是否为 int：
    -如果是int，说明有下一个元素，返回true；然后next()会被调用，把栈顶的int弹出
    -如果是list，需要把当前列表的各个元素逆序放入栈里
    -如果栈为空，说明原始嵌套列表已经结束，返回false
  举例说明，假如输入[1,[2,3]]

1. 在构造函数中：栈里面放的应该是 stack = [[2, 3], 1]
2. 在调用 `hasNext()` 方法时，访问栈顶元素是 1，为 int，那么直接返回 true;
3. 然后调用 `next()` 方法，弹出栈顶元素 1；
4. 再调用 `hasNext()` 方法时，访问栈顶元素是 [2,3]，为 list，那么需要摊平，继续放到栈中。当前的栈是 stack = [3, 2]
5. 然后调用 `next()` 方法，弹出栈顶元素 2；
6. 然后调用 `next()` 方法，弹出栈顶元素 3；
7. 再调用 `hasNext()` 方法时，栈为空，因此返回 false，迭代器运行结束。

public class NestedIterator implements Iterator<Integer>{
	private Deque<NestedIterator> deque; //存放结果
	public NestedIterator(List<NestedIterator> nestedList){
		deque = new ArrayDeque<>();
		// 将原列表中的每个元素放进栈中
		for(int i = nestedList.size() - 1; i >= 0; i--){
			deque.addLast(nestedList.get(i));
		}
	}
	
	@Override
    public Integer next() {
        NestedInteger cur = deque.removeLast();
        return cur.getInteger();
    }

    @Override
    public boolean hasNext() {
        while(!deque.isEmpty()){
            NestedInteger top = deque.peekLast();
            if(top.isInteger()){
                return true;
            }
            deque.removeLast();
            for(int i = top.getList().size() - 1 ; i >= 0 ; i--){
                deque.addLast(top.getList().get(i));
            }
        }
        return false;
    }
}