341. 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:

Input: [[1,1],2,[1,1]]
Output: [1,1,2,1,1]
Explanation: By calling next repeatedly until hasNext returns false, 
             the order of elements returned by next should be: [1,1,2,1,1].

Example 2:

Input: [1,[4,[6]]]
Output: [1,4,6]
Explanation: 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;
 };

---

题目给出一个vector<NestedInteger> nestedList, NestInteger是一种递归定义的类，我们要做是是将其展开。并从头开始判断nestedList中是否还存在Integer类型的元素，如果存在，就需要能够将其取出。

下面是利用递归的方式将nestedList展开的方法：

class NestedIterator {
public:
    NestedIterator(vector<NestedInteger> &nestedList) {
        flatten_list(nestedList);
    }

    int next() {
        NestedInteger top = priva_stk.top();
        priva_stk.pop();
        return top.getInteger();
    }

    bool hasNext() {
        if(priva_stk.empty())return false;
        return true;
    }

    void flatten_list(vector<NestedInteger> &nestedList)
    {
        for(int i = nestedList.size() - 1; i >= 0; i--)
        {
            if(nestedList[i].isInteger())
                priva_stk.push(nestedList[i].getInteger());
            else
                flatten_list(nestedList[i].getList());
        }
    }
private:
    stack<NestedInteger> priva_stk;
};

下面是在调用hasNext()时将nextedList部分展开的方法，即初始化的时候，将nextedList内的元素一股脑地装进栈中，并且是倒着装的，当调用hasNext()时，取出栈顶的元素，如果栈顶的元素仍是一个NestInteger，那么将其也展开，并倒着装进栈中。

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

    int next() {
        NestedInteger top = priva_stk.top();
        priva_stk.pop();
        return top.getInteger();
    }

    bool hasNext() {
        if(priva_stk.empty())return false;
        NestedInteger top = priva_stk.top();
        if(top.isInteger())return true;
        priva_stk.pop();
        vector<NestedInteger> nested = top.getList();
        for(int i = nested.size() - 1; i >= 0; i--)
            priva_stk.push(nested[i]);
        return hasNext();
    }
private:
    stack<NestedInteger> priva_stk;
};

www.sunshangyu.top