Solution1
We could use a stack to perform the iteration.
In the constructor we push the elements of nestedList
into the stack from back to front. So when we call pop()
, the very first element of nestedList
is returned. Afterwards, in the hasNext
function, we check the top element in the stack. If it is a Integer
, return true. Otherwise, we take out every element of the list and push them to the stack from back to front (flatten again). Until we find an Integer. The reason to do so is that there may be a lot of nested empty lists. Thus until we actually find an integer, we are not sure if there is a next integer.
Suppose the number of element we have to check, in the nestedList
, is n
. Then the time complexity is O(n)
.
/**
* // 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> {
Deque<NestedInteger> stack;
public NestedIterator(List<NestedInteger> nestedList) {
this.stack = new ArrayDeque<>();
for (int i = nestedList.size() - 1; i >= 0; i--) {
stack.push(nestedList.get(i));
}
}
@Override
public Integer next() {
if (!this.hasNext()) {
return null;
}
return stack.pop().getInteger();
}
@Override
public boolean hasNext() {
while (!stack.isEmpty()) {
NestedInteger curr = stack.pop();
if (curr.isInteger()) {
stack.push(curr);
return true;
} else {
for (int i = curr.getList().size() - 1; i >= 0; i--) {
stack.push(curr.getList().get(i));
}
}
}
return false;
}
}
/**
* Your NestedIterator object will be instantiated and called as such:
* NestedIterator i = new NestedIterator(nestedList);
* while (i.hasNext()) v[f()] = i.next();
*/
Solution2
Rather than perform the flatten process on the fly, we could flatten the nextedList
completely in the constructor.
Use a flattenHelper()
function to flatten the nextedList
recursively into a flattenedList
. And thus we could construct a Iterator<Integer>
based on the flattenedList
we got.
This is actually quicker than the previous one although they share the asymptotic time and space complexity. This could due to that a real Iterator<Integer>
is more efficient.
public class NestedIterator implements Iterator<Integer> {
private List<Integer> flattenedList;
private Iterator<Integer> it;
public NestedIterator(List<NestedInteger> nestedList) {
this.flattenedList = new ArrayList<Integer>();
flattenHelper(nestedList);
this.it = this.flattenedList.iterator();
}
private void flattenHelper(List<NestedInteger> nestedList) {
for (NestedInteger i : nestedList) {
if (i.isInteger()) {
this.flattenedList.add(i.getInteger());
} else {
flattenHelper(i.getList());
}
}
}
@Override
public Integer next() {
return this.it.next();
}
@Override
public boolean hasNext() {
return this.it.hasNext();
}
}