题目及测试
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;
}
}
}