Flatten 2D Vector

Problem Statement

Design a class Vector2D to flatten and iterate over a 2-dimensional vector (nested list). The iterator should provide the following operations:

• next() – Returns the current element and advances the iterator.
• hasNext() – Returns true if there are remaining elements to iterate through; otherwise, false.

Each inner list may be of different lengths, including empty. The iterator should correctly handle these edge cases.

Examples

Example 1

Input:

["Vector2D", "next", "next", "next", "hasNext", "hasNext", "next", "hasNext"]
[[[[1, 2], [3], [4]]], [], [], [], [], [], [], []]

Output:

[null, 1, 2, 3, true, true, 4, false]

Explanation:

Vector2D vector2D = new Vector2D([[1, 2], [3], [4]]);
vector2D.next();      // returns 1
vector2D.next();      // returns 2
vector2D.next();      // returns 3
vector2D.hasNext();   // returns true
vector2D.hasNext();   // returns true
vector2D.next();      // returns 4
vector2D.hasNext();   // returns false

Constraints

• 0 <= vec.length <= 200
• 0 <= vec[i].length <= 500
• -500 <= vec[i][j] <= 500
• Up to 10^5 calls to next() and hasNext() may be made.

Approach and Intuition

To manage iteration across a variable-length 2D vector efficiently, a dual-pointer approach is used:

1. Initialization

Maintain two indices:

• outer – tracks the current row in the 2D list.
• inner – tracks the current element within the current row.

This approach efficiently skips empty rows without flattening the entire list upfront.

2. hasNext() Method

Before attempting to access any element:

• Check whether the current outer index is within bounds.
• If the current row is empty or the inner index exceeds the row’s length, advance outer and reset inner.
• Repeat this until a valid position is found or the end of the structure is reached.

3. next() Method

• Always call hasNext() first to ensure a valid element exists.
• Return the current element and advance the inner index.

Benefits

• Avoids unnecessary memory use — does not pre-flatten the entire structure.
• Time-efficient — each element and sublist is processed at most once.
• Correctly handles empty lists, variable-length rows, and large volumes of method calls.

This structure ensures robust and responsive iterator behavior, even for edge cases like multiple empty inner lists or dynamic iterations at runtime.

Solutions

import java.util.NoSuchElementException;

class MatrixIterator {

    private int[][] matrix;
    private int rowPointer = 0;
    private int colPointer = 0;

    public MatrixIterator(int[][] m) {
        matrix = m;
    }

    private void skipToValid() {
        while (rowPointer < matrix.length && colPointer == matrix[rowPointer].length) {
            colPointer = 0;
            rowPointer++;
        }
    }

    public int next() {
        if (!hasNext()) throw new NoSuchElementException();
        return matrix[rowPointer][colPointer++];
    }

    public boolean hasNext() {
        skipToValid();
        return rowPointer < matrix.length;
    }
}