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.

Have you met this question in a real interview? 

Yes

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].

  这里在代码中需要保证stack中的第一个元素一定是integer类型，而非是nestedlist类型，因此要使用while在hasnext的处理时。

  java

  /**
   * // 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>();
          reverse(nestedList);
      }
  
      // @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.isEmpty() && !stack.peek().isInteger()) {
              reverse(stack.pop().getList());
          }
          return stack.isEmpty();
      }
  
      @Override
      public void remove() {}
      
      private void reverse(List<NestedInteger> list) {
          Stack<NestedInteger> temp = new Stack<>();
          for (NestedInteger val : list) {
              temp.push(val);
          }
          while (!temp.isEmpty()) {
              stack.push(temp.pop());
          }
      }
  }
  
  /**
   * Your NestedIterator object will be instantiated and called as such:
   * NestedIterator i = new NestedIterator(nestedList);
   * while (i.hasNext()) v.add(i.next());
   */