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

Example 1:
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].

Example 2:
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].

题目中给定的条件：

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */

分析NestedInteger这个类，发现他可以自身展开。如果只是一个Integer就可以返回Integer，否则只能返回一个vector，也就是题目中所谓的list。这个vector的元素就是NestedInteger。

方法1：
看一下样例发现题目需要我们依次展开list的每个元素，那遇到list*的元素就需要先展开list*的元素，所以这就可以看做是一个DFS，我用一个额外的O(n)空间来保存DFS的结果。遇到Integer元素直接存，遇到list元素就DFS这个list。

class NestedIterator {
public:
    NestedIterator(vector<NestedInteger> &nestedList){
        DFS(nestedList);
        it = res.begin();
    }
    int next() {
        return *it++;
    }
    bool hasNext() {
        return (it != res.end());
    }
private:
    list<int> res;
    list<int> :: iterator it;
    void DFS(const vector<NestedInteger> &nestedList){
        for(int i = 0; i < nestedList.size(); i++){
            if(nestedList[i].isInteger()) res.push_back(nestedList[i].getInteger());
            else DFS(nestedList[i].getList());
        }
    }
};

方法二：
做完题发现有个stack的标签，说明还有一种使用栈的方法。想了半天觉得并没有什么好的，空间还是很大。无非就是从后往前遍历vector加入stack。
需要注意[[]]这种情况，我们应该在hasNext()就拆开list，判断有没有next

class NestedIterator {
public:
    NestedIterator(vector<NestedInteger> &nestedList){
        for(int i = nestedList.size()-1; i >= 0; i--) res.push(nestedList[i]);

    }
    int next() {
        return Next;
    }
    bool hasNext() {
        while(!res.empty()){
            NestedInteger n = res.top();
            res.pop();
            if(n.isInteger() ) {
                Next = n.getInteger();
                return true;
            }
            vector<NestedInteger> &v = n.getList();
            for(int i = v.size()-1; i >=0; i--) res.push(v[i]);
        } return false;
    }
private:
    stack<NestedInteger> res;
    int Next;
};

---

2016.5.13 后记：
方法二虽然AC了，但是本质上是错误的。我在每次hasNext()就丢弃了一个元素，如果连续两次调用hasNext()，在调用next()就会出错了。
修改后的代码：

class NestedIterator {
public:
    NestedIterator(vector<NestedInteger> &nestedList){
        for(int i = nestedList.size()-1; i >= 0; i--) res.push(nestedList[i]);

    }
    int next() {
        int Next = res.top().getInteger();
        res.pop();
        return Next;
    }
    bool hasNext() {
        while(!res.empty()){
            NestedInteger n = res.top();
            if(n.isInteger() ) return true;
            res.pop();
            vector<NestedInteger> &v = n.getList();
            for(int i = v.size()-1; i >=0; i--) res.push(v[i]);
        } return false;
    }
private:
    stack<NestedInteger> res;
};