栈---扁平化嵌套列表迭代器

最新推荐文章于 2025-05-19 02:30:00 发布

原创最新推荐文章于 2025-05-19 02:30:00 发布 · 486 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#栈 #迭代器

算法专栏收录该内容

22 篇文章

订阅专栏

本文介绍了一种使用栈实现的迭代器，该迭代器能够遍历嵌套的整型列表，将所有整数按顺序返回。通过递归地处理嵌套列表并将整数值压入栈中，实现了对复杂嵌套结构的有效遍历。

题目
给定一个嵌套的整型列表。设计一个迭代器，使其能够遍历这个整型列表中的所有整数。
列表中的项或者为一个整数，或者是另一个列表。
示例

输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回false，next 返回的元素的顺序应该是: [1,1,2,1,1]。

输入: [1,[4,[6]]]
输出: [1,4,6]
解释: 通过重复调用 next 直到 hasNext 返回false，next 返回的元素的顺序应该是: [1,4,6]。

代码实现

这道题其实就是递归把每个嵌套的值放到一个数组中即可，但是这道题要求用栈来做，那么我们就倒着放到stack中，最后stack的栈顶元素就是数组对应的第一个元素。

public interface NestedInteger {
    public boolean isInteger();
    public Integer getInteger();
    public List<NestedInteger> getList();
}

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

    private List<NestedInteger> nestedList;
    private Stack<Integer> stack;


    public NestedIterator(List<NestedInteger> nestedList) {
        this.nestedList = nestedList;
        stack = new Stack<>();
        traverseList(stack,this.nestedList);
    }

    @Override
    public Integer next() {
        return stack.pop();
    }

    @Override
    public boolean hasNext() {
      return !stack.empty();
    }

    public void traverseList(Stack<Integer> stack, List<NestedInteger> nestedList){
        for (int i=nestedList.size()-1;i>=0;i--){
            NestedInteger nestedInteger = nestedList.get(i);
            if(nestedInteger.isInteger()){
                stack.push(nestedInteger.getInteger());
            }else{
               traverseList(stack,nestedInteger.getList());
            }
        }
    }
}

/**
 * Your NestedIterator object will be instantiated and called as such:
 * NestedIterator i = new NestedIterator(nestedList);
 * while (i.hasNext()) v[f()] = i.next();
 */