Diagonal Traverse II - Practice Coding Problems

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

Understanding the Visualization

Identify Pattern

Elements on same diagonal have equal row + column sums

Group Elements

Use coordinate sum as hash key to group diagonal elements

Traverse in Order

Process diagonals sequentially from sum 0 to maximum sum

Key Takeaway

🎯 Key Insight: The coordinate sum (row + col) uniquely identifies each diagonal, enabling efficient O(N) grouping and traversal of elements in the correct diagonal order.

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

Approach	Time	Space	Notes
✓ One-Pass Hash Map (Optimal)	O(N)	O(N)	Group elements by diagonal sum while traversing the array once
Sorting by Coordinates	O(N log N)	O(N)	Collect all coordinates with values and sort by diagonal sum, then row
Brute Force (Nested Loops)	O(M × N)	O(1)	Check every possible diagonal position systematically

One-Pass Hash Map (Optimal) — Algorithm Steps

Create a hash map where key is diagonal sum (row + col) and value is list of elements
Traverse the 2D array once, for each element at (i,j), add it to diagonal group (i+j)
Find the maximum diagonal sum encountered
Iterate through diagonal sums from 0 to maximum and collect all elements
Return the concatenated result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Map

Create a map where key = diagonal sum, value = list of elements

Single Traversal

Visit each element once, compute i+j, and add to corresponding diagonal group

Collect Results

Iterate through diagonal sums in ascending order and collect all elements

Code -

solution.c — C

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

typedef struct {
    int* elements;
    int size;
    int capacity;
} DiagonalList;

int* findDiagonalOrder(int** nums, int numsSize, int* numsColSize, int* returnSize) {
    if (!nums || numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // Find max diagonal and total elements
    int maxDiagonal = 0;
    int totalElements = 0;
    for (int i = 0; i < numsSize; i++) {
        totalElements += numsColSize[i];
        if (numsColSize[i] > 0) {
            int diagonal = i + numsColSize[i] - 1;
            if (diagonal > maxDiagonal) {
                maxDiagonal = diagonal;
            }
        }
    }
    
    // Create diagonal buckets
    DiagonalList* diagonals = (DiagonalList*)calloc(maxDiagonal + 1, sizeof(DiagonalList));
    
    // One pass: group elements by diagonal sum
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsColSize[i]; j++) {
            int diagonalSum = i + j;
            DiagonalList* diag = &diagonals[diagonalSum];
            
            if (diag->capacity == 0) {
                diag->capacity = 4;
                diag->elements = (int*)malloc(diag->capacity * sizeof(int));
            } else if (diag->size >= diag->capacity) {
                diag->capacity *= 2;
                diag->elements = (int*)realloc(diag->elements, diag->capacity * sizeof(int));
            }
            
            diag->elements[diag->size++] = nums[i][j];
        }
    }
    
    // Build result
    int* result = (int*)malloc(totalElements * sizeof(int));
    int resultIndex = 0;
    
    for (int diagonalSum = 0; diagonalSum <= maxDiagonal; diagonalSum++) {
        DiagonalList* diag = &diagonals[diagonalSum];
        for (int i = 0; i < diag->size; i++) {
            result[resultIndex++] = diag->elements[i];
        }
        if (diag->elements) free(diag->elements);
    }
    
    free(diagonals);
    *returnSize = resultIndex;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N)

We visit each element exactly once to build the hash map, then visit each element once more to build result - total O(N) where N is total number of elements

✓ Linear Growth

Space Complexity

O(N)

Hash map stores all N elements grouped by diagonals, plus the result array

✓ 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

One-Pass Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler