Flatten Nested List Iterator - Practice Coding Problems

Flatten Nested List Iterator - Problem

Stack Tree Depth-First Search Design Queue Iterator Medium

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. Your iterator class NestedIterator should have:

NestedIterator(List<NestedInteger> nestedList) - Initializes the iterator with the nested list
int next() - Returns the next integer in the nested list
boolean hasNext() - Returns true if there are still some integers in the nested list

Your code will be tested with the pseudocode:

initialize iterator with nestedList
res = []
while iterator.hasNext()
    append iterator.next() to the end of res
return res

If res matches the expected flattened list, your code is correct.

Input & Output

Example 1 — Nested Lists with Integers

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

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

💡 Note: First sublist [1,1] gives 1,1. Then integer 2. Finally sublist [1,1] gives 1,1. Result: [1,1,2,1,1]

Example 2 — Deeply Nested Structure

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

› Output: [1,4,6]

💡 Note: First element is 1. Second element [4,[6]] contains 4 and nested [6] which contains 6. Result: [1,4,6]

Example 3 — Empty Lists

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

› Output: [1,2,3]

💡 Note: Process 1, then 2, skip empty list [], then 3. Result: [1,2,3]

Constraints

1 ≤ nestedList.length ≤ 500
The values of the integers in the nested list is in the range [-10⁶, 10⁶]

Visualization

Tap to expand

next() → 1hasNext() → true
next() → 1hasNext() → true
next() → 2Iterator calls: hasNext(), next(), hasNext(), next(), ...

Understanding the Visualization

Input

Nested list with mixed integers and sublists

Iterator

Process elements in order, expanding lists as needed

Output

Flat sequence of all integers

Key Takeaway

🎯 Key Insight: Use a stack to handle nested structures efficiently, expanding lists only when needed for optimal memory usage

Asked in

G Google 25 f Facebook 20 a Amazon 15 M Microsoft 12

The key insight is to use a stack-based approach for lazy evaluation. The stack method processes nested structures on-demand, achieving O(n) time with O(d) space where d is nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Flatten All at Initialization	O(n)	O(n)	Pre-process entire nested list into flat array during initialization
Stack-Based Iterator	O(n)	O(d)	Use stack to process nested structure on-demand during iteration

Flatten All at Initialization — Algorithm Steps

Step 1: Recursively traverse entire nested list
Step 2: Store all integers in flat array
Step 3: Use array index for next() and hasNext()

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Recursively traverse and flatten entire structure

Store

All integers stored in flat array

Iterate

Simple array iteration for next() calls

Code -

solution.c — C

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

#define MAX_SIZE 10000

typedef struct {
    int flatList[MAX_SIZE];
    int size;
    int index;
} NestedIterator;

void flatten(NestedIterator* iter, int** nestedList, int* sizes, int numLists) {
    for (int i = 0; i < numLists; i++) {
        for (int j = 0; j < sizes[i]; j++) {
            iter->flatList[iter->size++] = nestedList[i][j];
        }
    }
}

NestedIterator* createIterator(int** nestedList, int* sizes, int numLists) {
    NestedIterator* iter = (NestedIterator*)malloc(sizeof(NestedIterator));
    iter->size = 0;
    iter->index = 0;
    flatten(iter, nestedList, sizes, numLists);
    return iter;
}

int next(NestedIterator* iter) {
    return iter->flatList[iter->index++];
}

int hasNext(NestedIterator* iter) {
    return iter->index < iter->size;
}

int main() {
    // Simplified input parsing
    int result[MAX_SIZE];
    int resultSize = 0;
    
    printf("[]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of all n elements during initialization, O(1) per next/hasNext call

✓ Linear Growth

Space Complexity

O(n)

Stores all n integers in a flat array

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Flatten All at Initialization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler