Diagonal Traverse II

Diagonal Traverse II - Problem

Diagonal Traverse II presents you with a fascinating 2D array traversal challenge! Given a 2D integer array nums (which may have rows of different lengths - a jagged array), your task is to traverse all elements diagonally and return them in a single array.

Unlike a regular matrix, this problem deals with jagged arrays where each row can have a different number of elements. You need to collect elements along each diagonal line, starting from the top-left and moving towards the bottom-right.

Key insight: Elements on the same diagonal share the property that their row + column indices are equal! For example, elements at positions (0,0), (1,0), (0,1) would be on different diagonals with sums 0, 1, and 1 respectively.

Goal: Return all elements traversed diagonally, where within each diagonal, elements are processed from top to bottom.

Input & Output

example_1.py — Python

$ Input: nums = [[1,2,3],[4,5],[6]]

› Output: [1,2,4,3,5,6]

💡 Note: Diagonal 0: [1] (sum=0), Diagonal 1: [2,4] (sum=1), Diagonal 2: [3,5,6] (sum=2). Concatenating gives [1,2,4,3,5,6].

example_2.py — Python

$ Input: nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]

› Output: [1,6,8,9,12,2,7,10,13,3,4,11,14,15,5,16]

💡 Note: Elements are grouped by diagonal sum: D0:[1], D1:[6,8,9,12], D2:[2,7,10,13], D3:[3,4,11,14,15], D4:[5,16]. Within each diagonal, elements appear in row order (top to bottom).

example_3.py — Python

$ Input: nums = [[1,2],[3,4,5,6]]

› Output: [1,3,2,4,5,6]

💡 Note: Simple case with two rows. D0:[1], D1:[3,2], D2:[4,5], D3:[6]. Note how elements from different rows can be on the same diagonal.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i].length ≤ 10⁵
1 ≤ sum(nums[i].length) ≤ 10⁵
1 ≤ nums[i][j] ≤ 10⁶
The input represents a jagged 2D array (rows can have different lengths)

Visualization

Tap to expand

Asked in

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

The optimal approach uses a hash map to group elements by their diagonal sum (row + col) during a single traversal. This achieves O(N) time complexity and handles jagged arrays naturally. The key insight is that elements on the same diagonal share the same coordinate sum, making grouping straightforward and efficient.

Common Approaches

✓ Brute Force (Nested Loops)

⏱️ Time: O(M × N) Space: O(1)

Generate all possible diagonals by iterating through all possible diagonal sums (from 0 to max_row + max_col). For each diagonal sum, check all valid (row, col) positions where row + col equals that sum.

One-Pass Hash Map (Optimal)

⏱️ Time: O(N) Space: O(N)

Use a hash map to group elements by their diagonal identifier (row + col). As we traverse the array once, we immediately categorize each element into its corresponding diagonal group. Finally, we concatenate all diagonal groups in order.

Sorting by Coordinates

⏱️ Time: O(N log N) Space: O(N)

First, extract all (row, col, value) tuples from the 2D array. Then sort these tuples by their diagonal sum (row + col), and by row index as secondary criteria to maintain correct order within each diagonal.

Brute Force (Nested Loops) — Algorithm Steps

Find the maximum possible diagonal sum by scanning the entire array
For each diagonal sum from 0 to maximum, iterate through all possible row indices
For each row, calculate the required column and check if it exists in that row
If the position exists, add the element to result
Continue until all diagonals are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Diagonal

Scan the entire array to find the maximum possible diagonal sum

Check Each Diagonal

For each diagonal sum from 0 to max, examine all valid positions

Validate Positions

Check if each computed (row, col) position actually exists in the jagged array

Collect Elements

Add valid elements to result array in diagonal order

Code -

solution.c — C

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

int* findDiagonalOrder(int** nums, int numsSize, int* numsColSize, int* returnSize) {
    if (!nums || numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // Find maximum diagonal sum possible
    int maxDiagonal = 0;
    for (int i = 0; i < numsSize; i++) {
        if (numsColSize[i] > 0) {
            int diagonal = i + numsColSize[i] - 1;
            if (diagonal > maxDiagonal) {
                maxDiagonal = diagonal;
            }
        }
    }
    
    // Count total elements for result array size
    int totalElements = 0;
    for (int i = 0; i < numsSize; i++) {
        totalElements += numsColSize[i];
    }
    
    int* result = (int*)malloc(totalElements * sizeof(int));
    int resultIndex = 0;
    
    // For each diagonal (identified by sum of indices)
    for (int diagonalSum = 0; diagonalSum <= maxDiagonal; diagonalSum++) {
        // For each possible row in this diagonal
        int maxRow = (diagonalSum < numsSize - 1) ? diagonalSum : numsSize - 1;
        for (int row = 0; row <= maxRow; row++) {
            int col = diagonalSum - row;
            // Check if this column exists in current row
            if (col < numsColSize[row]) {
                result[resultIndex++] = nums[row][col];
            }
        }
    }
    
    *returnSize = resultIndex;
    return result;
}

static int** nums;
static int* numsColSize;

int main() {
    char input[1000000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    int numsSize = 0;
    nums = (int**)malloc(100000 * sizeof(int*));
    numsColSize = (int*)malloc(100000 * sizeof(int));
    
    // Count rows
    char* ptr = input + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            numsSize++;
        }
        ptr++;
    }
    
    // Parse each row
    ptr = input + 1;
    int row = 0;
    while (*ptr && *ptr != ']' && row < numsSize) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            nums[row] = (int*)malloc(100000 * sizeof(int));
            numsColSize[row] = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    nums[row][numsColSize[row]++] = num;
                } else {
                    ptr++;
                }
            }
            if (*ptr == ']') ptr++;
            row++;
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int* result = findDiagonalOrder(nums, numsSize, numsColSize, &returnSize);
    
    // Output result
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("\n");
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(nums[i]);
    }
    free(nums);
    free(numsColSize);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M × N)

We potentially check every possible position in an M×N bounding rectangle, even if many positions don't exist in the jagged array

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, result array not counted as extra space

✓ Linear Space

89.2K Views

High Frequency

~18 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler