116 lines
2.8 KiB
C++
116 lines
2.8 KiB
C++
#include <vector>
|
|
#include <functional>
|
|
|
|
// This is the interface that allows for creating nested lists.
|
|
// You should not implement it, or speculate about its implementation
|
|
class NestedInteger {
|
|
private:
|
|
std::vector<NestedInteger> content;
|
|
|
|
int x = 0x7FFFFFFF;
|
|
|
|
public:
|
|
// Constructor initializes an empty nested list.
|
|
explicit NestedInteger();
|
|
|
|
// Constructor initializes a single integer.
|
|
explicit NestedInteger(int value);
|
|
|
|
// 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;
|
|
|
|
// Set this NestedInteger to hold a single integer.
|
|
void setInteger(int value);
|
|
|
|
// Set this NestedInteger to hold a nested list and adds a nested integer to it.
|
|
void add(const NestedInteger& ni);
|
|
|
|
// 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
|
|
[[nodiscard]] const std::vector<NestedInteger>& getList() const;
|
|
};
|
|
|
|
/**
|
|
* 341. Flatten Nested List Iterator
|
|
* You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists. Implement an iterator to flatten it.
|
|
*
|
|
* Implement the NestedIterator class:
|
|
*
|
|
* NestedIterator(List<NestedInteger> nestedList) Initializes the iterator with the nested list nestedList.
|
|
* int next() Returns the next integer in the nested list.
|
|
* boolean hasNext() Returns true if there are still some integers in the nested list and false otherwise.
|
|
*/
|
|
|
|
class NestedIterator {
|
|
private:
|
|
int v[512];
|
|
int ptr = 0, rear = 0;
|
|
|
|
void dfs(const NestedInteger& n) {
|
|
if (n.isInteger())
|
|
v[rear++] = n.getInteger();
|
|
else {
|
|
const auto& list = n.getList();
|
|
const int s = list.size();
|
|
for (int i = 0; i < s; ++i)
|
|
dfs(list[i]);
|
|
}
|
|
}
|
|
|
|
public:
|
|
explicit NestedIterator(const std::vector<NestedInteger>& list) {
|
|
const int s = list.size();
|
|
for (int i = 0; i < s; ++i)
|
|
dfs(list[i]);
|
|
}
|
|
|
|
int next() {
|
|
return v[ptr++];
|
|
}
|
|
|
|
bool hasNext() {
|
|
return ptr < rear;
|
|
}
|
|
};
|
|
|
|
|
|
int main() {
|
|
return 0;
|
|
}
|
|
|
|
NestedInteger::NestedInteger() = default;
|
|
|
|
NestedInteger::NestedInteger(int value) : x(value) {}
|
|
|
|
bool NestedInteger::isInteger() const {
|
|
return x < 0x7FFFFFFE;
|
|
}
|
|
|
|
int NestedInteger::getInteger() const {
|
|
return x;
|
|
}
|
|
|
|
void NestedInteger::setInteger(int value) {
|
|
x = value;
|
|
content.clear();
|
|
}
|
|
|
|
void NestedInteger::add(const NestedInteger& ni) {
|
|
if (!this->isInteger()) {
|
|
content.push_back(ni);
|
|
return;
|
|
}
|
|
content.clear();
|
|
content.emplace_back(x);
|
|
content.push_back(ni);
|
|
x = 0x7FFFFFFF;
|
|
}
|
|
|
|
const std::vector<NestedInteger>& NestedInteger::getList() const {
|
|
return content;
|
|
}
|