Flatten 2D Vector - Practice Coding Problems

Flatten 2D Vector - Problem

You're tasked with designing an iterator that can seamlessly traverse through a 2D vector as if it were a flat, one-dimensional array. Think of it like reading a book page by page, word by word, from left to right and top to bottom.

Your Vector2D class needs to implement:

Constructor: Vector2D(int[][] vec) - Initialize with a 2D vector
next(): Return the next element and advance the pointer
hasNext(): Check if there are more elements to iterate over

Challenge: You need to handle empty rows gracefully and ensure optimal space usage - don't flatten everything upfront!

Example: Given [[1,2],[3],[4,5,6]], your iterator should return elements in order: 1 → 2 → 3 → 4 → 5 → 6

Input & Output

example_1.py — Basic Usage

$ Input: vec = [[1,2],[3],[4,5,6]]<br/>Operations: hasNext(), next(), next(), hasNext(), next(), hasNext(), next(), next(), hasNext()

› Output: [true, 1, 2, true, 3, true, 4, 5, false]

💡 Note: The iterator traverses through all elements in row-major order: 1→2→3→4→5→6, then returns false when no more elements exist.

example_2.py — Empty Rows

$ Input: vec = [[1],[],[2,3]]<br/>Operations: hasNext(), next(), hasNext(), next(), next(), hasNext()

› Output: [true, 1, true, 2, 3, false]

💡 Note: Empty rows are automatically skipped. The iterator goes directly from element 1 to element 2, ignoring the empty middle row.

example_3.py — All Empty

$ Input: vec = [[],[],[]]<br/>Operations: hasNext()

› Output: [false]

💡 Note: When all rows are empty, hasNext() immediately returns false as there are no elements to iterate over.

Visualization

Tap to expand

Understanding the Visualization

Position Tracking

Keep track of current row and column position in the 2D structure

Lazy Evaluation

Only advance position when hasNext() or next() is called, not during initialization

Empty Row Handling

Automatically skip over empty rows to find the next valid element

Boundary Detection

Detect when we've reached the end of all rows to return false for hasNext()

Key Takeaway

🎯 Key Insight: Use two pointers to maintain current position in 2D structure. The advance-to-next helper function handles empty row skipping, making the iterator robust and memory-efficient.

Time & Space Complexity

Time Complexity

⏱️

O(n) initialization, O(1) per operation

Need to traverse all n elements once during construction, then each operation is constant time

✓ Linear Growth

Space Complexity

O(n)

Store all n elements in additional flat array

⚡ Linearithmic Space

Constraints

0 ≤ vec.length ≤ 200
0 ≤ vec[i].length ≤ 500
-500 ≤ vec[i][j] ≤ 500
At most 10⁵ calls to next and hasNext
Follow up: Can you implement it without flattening the 2D vector?

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28 Apple 22 t Twitter 18

The optimal solution uses two pointers (row and column) to traverse the 2D vector lazily without extra space. Key insight: maintain current position and skip empty rows automatically in hasNext(). This achieves O(1) space and O(1) amortized time per operation while handling edge cases gracefully.

Common Approaches

Approach	Time	Space	Notes
✓ Flatten All Elements Upfront	O(n) initialization, O(1) per operation	O(n)	Flatten the entire 2D vector into a 1D array during initialization
Two Pointers (Optimal Iterator)	O(1) amortized per operation	O(1)	Use row and column pointers to traverse 2D vector lazily without extra space

Flatten All Elements Upfront — Algorithm Steps

In constructor, create an empty list
Iterate through each row of the 2D vector
For each non-empty row, add all elements to the flat list
Keep a current index pointer for iteration
hasNext() checks if index < list size
next() returns current element and increments index

Visualization

Tap to expand

Step-by-Step Walkthrough

Input 2D Vector

Original nested structure with multiple rows

Flatten Process

Copy all elements row by row into flat array

Iterator State

Use simple index to track current position

Code -

solution.c — C

#include <stdlib.h>

typedef struct {
    int* flat;
    int size;
    int index;
} Vector2D;

Vector2D* vector2DCreate(int** vec, int vecSize, int* vecColSize) {
    Vector2D* obj = (Vector2D*)malloc(sizeof(Vector2D));
    obj->size = 0;
    
    // Count total elements
    for (int i = 0; i < vecSize; i++) {
        obj->size += vecColSize[i];
    }
    
    obj->flat = (int*)malloc(obj->size * sizeof(int));
    obj->index = 0;
    
    int pos = 0;
    for (int i = 0; i < vecSize; i++) {
        for (int j = 0; j < vecColSize[i]; j++) {
            obj->flat[pos++] = vec[i][j];
        }
    }
    
    return obj;
}

int vector2DNext(Vector2D* obj) {
    return obj->flat[obj->index++];
}

bool vector2DHasNext(Vector2D* obj) {
    return obj->index < obj->size;
}

Time & Space Complexity

Time Complexity

⏱️

O(n) initialization, O(1) per operation

Need to traverse all n elements once during construction, then each operation is constant time

✓ Linear Growth

Space Complexity

O(n)

Store all n elements in additional flat array

⚡ Linearithmic Space

Constraints

0 ≤ vec.length ≤ 200
0 ≤ vec[i].length ≤ 500
-500 ≤ vec[i][j] ≤ 500
At most 10⁵ calls to next and hasNext
Follow up: Can you implement it without flattening the 2D vector?

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.9K 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

Flatten All Elements Upfront — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler