[Leetcode学习-c++&java]Flatten Nested List Iterator

问题：

难度：medium

说明：

给出一个嵌套的 list， 现在需要把所有嵌套的元素都逐个遍历，写一个迭代器处理。

题目连接：https://leetcode.com/problems/flatten-nested-list-iterator/submissions/

输入范围：

• 1 <= nestedList.length <= 500
• The values of the integers in the nested list is in the range [-106, 106].

输入案例：

Example 1:
Input: nestedList = [[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: nestedList = [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].

---

我的代码：

只是写个迭代器，先预留一个 tempList 然后每次遍历都把新增的元素放到里面，因为嵌套的话，一个元素可能有多个，所以为了不经常跑去解包，所以把一整个嵌套的都弄出来最好。

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 empty list if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class NestedIterator implements Iterator<Integer> {

    int nestedIdx, tempIdx, nlen;
    List<NestedInteger> nestedList;
    List<Integer> tempList = new ArrayList<Integer>();
    
    public NestedIterator(List<NestedInteger> nestedList) {
        this.nestedList = nestedList;
        this.nlen = nestedList.size();
    }

    @Override
    public Integer next() {
        if(!hasNext()) return -1;
        return tempList.get(tempIdx ++);
    }
    
    public void rePackage(NestedInteger n, List<Integer> tempList) {
        if(n.isInteger()) {
            tempList.add(n.getInteger());
        } else {
            List<NestedInteger> list = n.getList();
            for(NestedInteger nxt : list) {
                rePackage(nxt, tempList);
            }
        }
    }

    @Override
    public boolean hasNext() {
        while(tempIdx == tempList.size() && nestedIdx < nlen) {
            NestedInteger n = nestedList.get(nestedIdx ++);
            rePackage(n, tempList);
        }
        return tempIdx != tempList.size();
    }
}

C++：

/**
 * // 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;
 * };
 */

class NestedIterator {
public:
	int tempIdx = 0, nIdx = 0, nLen = 0;
	vector<NestedInteger> nList;
	vector<int> tempList;
	NestedIterator(vector<NestedInteger> &nestedList) {
		nList = nestedList;
		nLen = nestedList.size();
	}

	int next() {
		if (!hasNext()) return -1;
		return tempList[tempIdx++];
	}

	bool hasNext() {
		while (tempIdx == tempList.size() && nIdx < nLen) {
			NestedInteger n = nList[nIdx++];
			rePackage(&n, &tempList);
		}
		return tempIdx != tempList.size();
	}

	void rePackage(NestedInteger *n, vector<int> *tempList) {
		if (n->isInteger()) {
			tempList->push_back(n->getInteger());
		}
		else {
			vector<NestedInteger> list = n->getList();
			for (int i = 0, len = list.size(); i < len; i++) {
				rePackage(&list[i], tempList);
			}
		}
	}
};