Flatten Nested List Iterator

Given a nested list of integers, implement an iterator to flatten it. Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Notice You don't need to implement the remove method.

Example

• Given the list [[1,1],2,[1,1]], By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

• Given the list [1,[4,[6]]], By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

题目中的NestedInteger应该是实际当中General Grouping Object (or Container)的特例。看到这种数据结构的第一反应就是用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<NestedInteger> getList();
  * }
  */
 import java.util.Iterator;

 public class NestedIterator implements Iterator<Integer> {

     Stack<NestedInteger> stack;
     public NestedIterator(List<NestedInteger> nestedList) {
         // Initialize your data structure here.
         stack = new Stack<NestedInteger>();
         if(nestedList!=null){
             for(int i=nestedList.size()-1;i>=0;i--){
                 stack.push(nestedList.get(i));
             }
         }
     }

     // @return {int} the next element in the iteration
     @Override
     public Integer next() {
         // Write your code here
         return stack.pop().getInteger();
     }

     // @return {boolean} true if the iteration has more element or false
     @Override
     public boolean hasNext() {
         // Write your code here
         while(!stack.empty()){
             NestedInteger cur = stack.peek();
             if(cur.isInteger()) return true;
             stack.pop();
             List<NestedInteger> list = cur.getList();
             if(list!=null){
                 for(int i=list.size()-1;i>=0;i--){
                     stack.push(list.get(i));
                 }
             }
         }
         return false;
     }

     @Override
     public void remove() {}
 }

 /**
  * Your NestedIterator object will be instantiated and called as such:
  * NestedIterator i = new NestedIterator(nestedList);
  * while (i.hasNext()) v.add(i.next());
  */