java双层list扁平化,leetcode-341-扁平化嵌套列表迭代器-java

题目及测试

package pid341;

/* 扁平化嵌套列表迭代器

给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。

列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。

示例 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]。

*/

public class main {

public static void main(String[] args) {

}

}

package pid341;

import java.util.Iterator;

import java.util.List;

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 getList();

}

解法1(成功，4ms，较快)

内部有一个stack，index大的先放进去，小的后放进去。next时，弹出最上面的，如果是数字，直接返回。如果不是数字，将列表从后到前依次放进stack，然后再次调用next方法。

hasNext，由于会出现stack不为空，但是NestInteger为{}的情况，需要先调用next得到返回的结果不为null，再返回true，同时把返回的结果放到nextInteger里面，next方法优先返回nextInteger，然后清空这个字段

package pid341;

import java.util.Iterator;

import java.util.List;

import java.util.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 getList();

* }

*/

public class NestedIterator implements Iterator {

private Stack stack = new Stack<>();

// 如果调用了hasNext方法，会把下一次返回的结果存在里面，next方法会返回这个结果，并清空这个字段

Integer nextInteger = null;

public NestedIterator(List nestedList) {

if(nestedList.size() == 0){

return;

}

for(int i=nestedList.size()-1;i>=0;i--){

stack.push(nestedList.get(i));

}

}

@Override

public Integer next() {

if(nextInteger != null){

Integer result = nextInteger;

nextInteger = null;

return result;

}

if(stack.isEmpty()){

return null;

}

NestedInteger now = stack.pop();

if(now.isInteger()){

return now.getInteger();

}else{

List nestedList = now.getList();

if(nestedList.size() != 0){

for(int i=nestedList.size()-1;i>=0;i--){

stack.push(nestedList.get(i));

}

}

return next();

}

}

@Override

public boolean hasNext() {

if(stack.isEmpty()){

return false;

}else{

Integer now = next();

if(now==null){

return false;

}else{

nextInteger = now;

return true;

}

}

}

}

/**

* Your NestedIterator object will be instantiated and called as such:

* NestedIterator i = new NestedIterator(nestedList);

* while (i.hasNext()) v[f()] = i.next();

*/

解法2(别人的)

简单粗暴，在初始化迭代器的时候就直接把结果遍历出来，递归遍历列表中的数据，是整数就放入List，不是则再递归遍历，代码结构简单。

public class NestedIterator implements Iterator {

private List list;

private int index;

public NestedIterator(List nestedList) {

list = integerIterator(nestedList);

index = -1;

}

@Override

public Integer next() {

if (this.hasNext()) return list.get(++index);

return null;

}

@Override

public boolean hasNext() {

if (index + 1 < list.size()) return true;

return false;

}

private static List integerIterator(List nestedIntegerList) {

ArrayList list = new ArrayList<>(nestedIntegerList.size());

for (NestedInteger tmp : nestedIntegerList) {

if (tmp.isInteger())

list.add(tmp.getInteger());

else

list.addAll(integerIterator(tmp.getList()));

}

return list;

}

}

解法3(别人的)

在类中添加nestedList、stack、iteratot、integer四个属性，分别对应嵌套列表、迭代器存储栈、当前迭代器、当前遍历整数

构造函数初始化nestedList、iterator，iterator对应的就是构造参数的迭代器。

重写hasNext()函数，主要逻辑为：

当前迭代器若hasNext()为true

判断next()是否为整数，若为整数则赋值integer，返回``true`

判断next()是否为列表，则将当前迭代器暂存至stack,并更新iterator为当前列表的迭代器，递归hasNext()函数

当前迭代器若hasNext()为false且stack非空，则迭代器出栈更新为当前iterator，递归hasNext()函数

其他情况则代表，整个扁平化嵌套列表已遍历完毕，返回false

重写next()函数，迭代器的使用规则是hasNext()返回为true时调用next()函数获取下一值，再次直接返回integer(当前遍历整数)即可。

public class NestedIterator implements Iterator {

//嵌套列表

private List nestedList = null;

//迭代器存储栈

private Stack> stack = new Stack<>();

//当前迭代器

private Iterator iterator = null;

//当前遍历整数

private Integer integer = 0;

public NestedIterator(List nestedList) {

//嵌套列表初始化

this.nestedList = nestedList;

iterator = nestedList.iterator();

}

@Override

public Integer next() {

return integer;

}

@Override

public boolean hasNext() {

if(iterator.hasNext()) {

NestedInteger nestedInteger = iterator.next();

if (!nestedInteger.isInteger()) {

//该值为列表

stack.push(iterator);

iterator = nestedInteger.getList().iterator();

return hasNext();

} else {

integer = nestedInteger.getInteger();

return true;

}

}else if(!iterator.hasNext() && !stack.isEmpty()) {

//当前迭代器至列表末尾并且栈非空

//迭代器更新为上一级

iterator = stack.pop();

return hasNext();

}else{

return false;

}

}

}