Flatten Nested List Iterator - Practice Coding Problems

Flatten Nested List Iterator - Problem

Stack Tree Depth-First Search Design Queue Iterator Medium

You're given a nested list of integers where each element can be either an integer or another list containing integers or more nested lists. Your task is to design an iterator that can traverse through all the integers in a flattened manner.

Think of it like exploring a filing cabinet with folders inside folders - you need to visit every document (integer) regardless of how deeply nested it is!

Implement the NestedIterator class:

NestedIterator(List<NestedInteger> nestedList) - Initialize the iterator
int next() - Return the next integer in flattened order
boolean hasNext() - Check if there are more integers to visit

Example: Given [[1,1],2,[1,1]], your iterator should return 1, 1, 2, 1, 1 in that order.

Input & Output

example_1.py — Basic nested list

$ Input: nestedList = [[1,1],2,[1,1]]

› Output: [1,1,2,1,1]

💡 Note: The iterator should flatten the nested structure and return each integer in order: first 1 and 1 from [1,1], then 2, then 1 and 1 from the second [1,1].

example_2.py — Deeply nested

$ Input: nestedList = [1,[4,[6]]]

› Output: [1,4,6]

💡 Note: The nested structure contains: 1 at the top level, then 4 inside a list, then 6 inside a nested list within that list.

example_3.py — Empty lists

$ Input: nestedList = [1,[],[],[4,[]]]

› Output: [1,4]

💡 Note: Empty lists should be ignored. Only the integers 1 and 4 are returned, skipping all empty nested lists.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Put all top-level elements on stack in reverse order

hasNext() check

If top is a list, open it and put contents on stack

Ready for next()

Top of stack is guaranteed to be an integer

Return integer

Pop and return the integer from stack top

Key Takeaway

🎯 Key Insight: The stack simulates recursive traversal while providing lazy evaluation - we only flatten nested lists when we actually need to access their elements, making it memory efficient and truly iterator-like.

Time & Space Complexity

Time Complexity

⏱️

O(1) amortized

Each element is pushed and popped exactly once, so amortized O(1) per operation

✓ Linear Growth

Space Complexity

O(d)

O(d) where d is the maximum depth of nesting, for the stack storage

✓ Linear Space

Constraints

1 ≤ nestedList.length ≤ 500
The values of the integers in the nested list are in the range [-10⁶, 10⁶]
The total number of integers in the nested list is at most 10⁴

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a stack-based iterator that lazily flattens the nested structure on-demand. This provides O(1) amortized time complexity per operation with O(d) space complexity where d is the maximum nesting depth. The key insight is to use the stack to simulate recursive traversal while maintaining proper ordering by pushing elements in reverse order.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Iterator (Optimal)	O(1) amortized	O(d)	Use a stack to lazily flatten the nested structure on-demand

Stack-Based Iterator (Optimal) — Algorithm Steps

Initialize stack with all elements from nestedList in reverse order
In hasNext(), ensure top of stack is an integer (flatten if needed)
If top element is a list, pop it and push its contents in reverse order
Repeat until stack is empty or top is an integer
next() pops and returns the integer from top of stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Push [[1,1],2,[1,1]] in reverse order

hasNext() Call

Top is [1,1] (list), so flatten it

Stack Updated

Stack now has individual integers ready

next() Call

Pop and return the integer from top

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    struct NestedInteger** stack;
    int top;
    int capacity;
} NestedIterator;

NestedIterator* nestedIterCreate(struct NestedInteger** nestedList, int nestedListSize) {
    NestedIterator* ni = malloc(sizeof(NestedIterator));
    ni->capacity = 1000;
    ni->stack = malloc(ni->capacity * sizeof(struct NestedInteger*));
    ni->top = 0;
    
    for (int i = nestedListSize - 1; i >= 0; i--) {
        ni->stack[ni->top++] = nestedList[i];
    }
    return ni;
}

int nestedIterNext(NestedIterator* ni) {
    struct NestedInteger* top = ni->stack[--ni->top];
    return NestedIntegerGetInteger(top);
}

bool nestedIterHasNext(NestedIterator* ni) {
    while (ni->top > 0) {
        struct NestedInteger* top = ni->stack[ni->top - 1];
        if (NestedIntegerIsInteger(top)) {
            return true;
        }
        ni->top--;
        int listSize;
        struct NestedInteger** nestedList = NestedIntegerGetList(top, &listSize);
        for (int i = listSize - 1; i >= 0; i--) {
            ni->stack[ni->top++] = nestedList[i];
        }
    }
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) amortized

Each element is pushed and popped exactly once, so amortized O(1) per operation

✓ Linear Growth

Space Complexity

O(d)

O(d) where d is the maximum depth of nesting, for the stack storage

✓ Linear Space

Constraints

1 ≤ nestedList.length ≤ 500
The values of the integers in the nested list are in the range [-10⁶, 10⁶]
The total number of integers in the nested list is at most 10⁴

67.2K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-Based Iterator (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler