Diagonal Traverse - Practice Coding Problems

Diagonal Traverse - Problem

Matrix Diagonal Traversal

Given an m x n matrix, you need to traverse all elements in a diagonal pattern and return them as a single array. The traversal follows a unique zigzag pattern:

• Start from the top-left corner (0,0)
• Move diagonally up-right, then down-left, then up-right again
• When you hit a boundary, change direction and move to the next diagonal
• Continue until all elements are visited

Example: For matrix [[1,2,3],[4,5,6],[7,8,9]], the diagonal traversal would be [1,2,4,7,5,3,6,8,9]

This problem tests your ability to simulate movement patterns and handle boundary conditions in 2D matrices.

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]]

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

💡 Note: Starting from (0,0), we move diagonally up-right to collect 1,2, then hit boundary and move down-left for 4, then up-right for 7,5,3, and so on following the zigzag pattern.

example_2.py — Rectangular Matrix

$ Input: mat = [[1,2],[3,4]]

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

💡 Note: For a 2x2 matrix: start with 1, move up-right to 2, then down-left to 3, finally to 4. The diagonal pattern creates the sequence [1,2,3,4].

example_3.py — Single Row Edge Case

$ Input: mat = [[1,2,3,4]]

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

💡 Note: With only one row, each element forms its own diagonal. Since we alternate direction but can't move up or down, we simply traverse left to right: [1,2,3,4].

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start at top-left (0,0) with up-right direction

Move Diagonally

Continue in current direction until hitting a boundary

Handle Boundaries

Change direction and find next starting position based on boundary rules

Repeat Pattern

Continue alternating directions until all elements are visited

Key Takeaway

🎯 Key Insight: The diagonal traversal creates a zigzag pattern where direction changes occur at matrix boundaries, following predictable rules that can be simulated efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell once to group by diagonal, then once more to build result

✓ Linear Growth

Space Complexity

O(m×n)

Extra space needed to store all diagonals before processing

⚡ Linearithmic Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ m * n ≤ 10⁴
-10⁵ ≤ mat[i][j] ≤ 10⁵

Asked in

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

The optimal solution uses direction simulation with O(m×n) time and O(1) space complexity. The key insight is to track current position and direction, changing direction when hitting matrix boundaries. This approach directly simulates the diagonal traversal pattern without needing extra data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Diagonal Collection)	O(m×n)	O(m×n)	Collect all diagonals separately, then merge with alternating direction
Direction Simulation (Optimal)	O(m×n)	O(1)	Simulate the diagonal movement with direction changes at boundaries

Brute Force (Diagonal Collection) — Algorithm Steps

Identify all diagonal lines by their sum of indices (i+j)
Group elements by diagonal index
For even diagonals, read from bottom-left to top-right
For odd diagonals, read from top-right to bottom-left
Concatenate all processed diagonals

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Diagonal Sum

Elements with same i+j value belong to same diagonal

Identify Direction

Even diagonals go up-right, odd diagonals go down-left

Process Each Diagonal

Reverse even diagonals and concatenate all results

Code -

solution.c — C

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

int* findDiagonalOrder(int** mat, int matSize, int* matColSize, int* returnSize) {
    if (matSize == 0 || matColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int m = matSize, n = matColSize[0];
    int* result = (int*)malloc(m * n * sizeof(int));
    int idx = 0;
    
    // Process each diagonal
    for (int d = 0; d < m + n - 1; d++) {
        int* diagonal = (int*)malloc(sizeof(int) * (m + n));
        int count = 0;
        
        // Collect diagonal elements
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i + j == d) {
                    diagonal[count++] = mat[i][j];
                }
            }
        }
        
        // Add to result (reverse for even diagonals)
        if (d % 2 == 0) {
            for (int i = count - 1; i >= 0; i--) {
                result[idx++] = diagonal[i];
            }
        } else {
            for (int i = 0; i < count; i++) {
                result[idx++] = diagonal[i];
            }
        }
        
        free(diagonal);
    }
    
    *returnSize = m * n;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell once to group by diagonal, then once more to build result

✓ Linear Growth

Space Complexity

O(m×n)

Extra space needed to store all diagonals before processing

⚡ Linearithmic Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ m * n ≤ 10⁴
-10⁵ ≤ mat[i][j] ≤ 10⁵

42.0K Views

Medium-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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Diagonal Collection) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler