# 扁平化嵌套列表迭代器
给你一个嵌套的整数列表 nestedList 。每个元素要么是一个整数，要么是一个列表；该列表的元素也可能是整数或者是其他列表。请你实现一个迭代器将其扁平化，使之能够遍历这个列表中的所有整数。
实现扁平迭代器类 NestedIterator ：
NestedIterator(List<NestedInteger> nestedList) 用嵌套列表 nestedList 初始化迭代器。int next() 返回嵌套列表的下一个整数。boolean hasNext() 如果仍然存在待迭代的整数，返回 true ；否则，返回 false 。
你的代码将会用下述伪代码检测：
initialize iterator with nestedList
res = []
while iterator.hasNext()
append iterator.next() to the end of res
return res
如果 res 与预期的扁平化列表匹配，那么你的代码将会被判为正确。
示例 1：
输入：nestedList = [[1,1],2,[1,1]]
输出：[1,1,2,1,1]
解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。
示例 2：
输入：nestedList = [1,[4,[6]]]
输出：[1,4,6]
解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。
提示：
1 <= nestedList.length <= 500- 嵌套列表中的整数值在范围
[-106, 106] 内
以下错误的选项是？
## aop
### before
```cpp
#include
using namespace std;
// 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 &getList() const;
};
```
### after
```cpp
```
## 答案
```cpp
class NestedIterator
{
public:
vector data;
vector::iterator it;
NestedIterator(vector &nestedList)
{
parse(nestedList);
it = data.begin();
}
void parse(vector &nestedList)
{
for (auto nes : nestedList)
{
data.push_back(nes.getInteger());
parse(nes.getList());
}
}
int next()
{
return *it++;
}
bool hasNext()
{
return it != data.end();
}
};
```
## 选项
### A
```cpp
class NestedIterator
{
public:
stack st;
NestedIterator(vector &nestedList)
{
for (int i = nestedList.size() - 1; i >= 0; --i)
st.push(&nestedList[i]);
}
int next()
{
int res = st.top()->getInteger();
st.pop();
return res;
}
bool hasNext()
{
if (st.empty())
return false;
NestedInteger *tmp = st.top();
while (!tmp->isInteger())
{
st.pop();
vector &list = tmp->getList();
for (int i = list.size() - 1; i >= 0; --i)
st.push(&list[i]);
if (st.empty())
return false;
tmp = st.top();
}
return true;
}
};
```
### B
```cpp
class NestedIterator
{
public:
int cnt = 0;
vector ans;
void dfs(vector &nestedList)
{
for (auto l : nestedList)
{
if (l.isInteger())
ans.push_back(l.getInteger());
else
dfs(l.getList());
}
}
NestedIterator(vector &nestedList)
{
dfs(nestedList);
}
int next()
{
return ans[cnt++];
}
bool hasNext()
{
return cnt < ans.size();
}
};
```
### C
```cpp
class NestedIterator
{
stack::iterator> begins, ends;
public:
NestedIterator(vector &nestedList)
{
begins.push(nestedList.begin());
ends.push(nestedList.end());
}
int next()
{
hasNext();
return (begins.top()++)->getInteger();
}
bool hasNext()
{
vector::iterator tp;
while (!begins.empty())
{
if (begins.top() == ends.top())
{
begins.pop();
ends.pop();
}
else
{
tp = begins.top();
if (tp->isInteger())
return true;
begins.top()++;
begins.push(tp->getList().begin());
ends.push(tp->getList().end());
;
}
}
return false;
}
};
```