Sort the Matrix Diagonally - Practice Coding Problems

Sort the Matrix Diagonally - Problem

Sort the Matrix Diagonally is a fascinating matrix manipulation problem that challenges you to think about diagonal patterns in 2D arrays.

Imagine a matrix where you need to sort each diagonal line that runs from top-left to bottom-right. A matrix diagonal is defined as a line of cells starting from either:
• Any cell in the topmost row (first row)
• Any cell in the leftmost column (first column)

Each diagonal continues in the bottom-right direction until it reaches the matrix boundary.

Example: In a 6×3 matrix, the diagonal starting from mat[2][0] includes cells mat[2][0] → mat[3][1] → mat[4][2].

Your task: Given an m × n matrix of integers, sort each diagonal in ascending order and return the transformed matrix.

🎯 Goal: Transform the matrix so that every diagonal from top-left to bottom-right is sorted in ascending order.

Input & Output

basic_3x3_matrix.py — Python

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

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

💡 Note: Each diagonal is sorted: main diagonal [3,2,1] becomes [1,2,3], diagonal starting from [0,1] is [3,2,1] becomes [1,2,3], and so on.

single_element.py — Python

$ Input: mat = [[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]]

› Output: [[5,17,4,1,52,7],[11,11,25,45,8,69],[14,23,25,44,58,15],[22,27,31,36,50,66],[84,28,75,33,55,68]]

💡 Note: A larger matrix where each diagonal from top-left to bottom-right is sorted independently while maintaining the original matrix structure.

edge_case_single.py — Python

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

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

💡 Note: In a 2x2 matrix, each diagonal has only one element, so no sorting is needed and the matrix remains unchanged.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
1 ≤ mat[i][j] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Identify Diagonal Patterns

Recognize that cells sharing the same (row - col) value belong to the same diagonal

Group Elements

Collect all elements from each diagonal using the mathematical invariant

Sort Each Group

Sort elements within each diagonal group in ascending order

Redistribute

Place sorted elements back to their respective diagonal positions

Key Takeaway

🎯 Key Insight: The mathematical property (i-j = constant) for diagonal elements allows us to efficiently group, sort, and redistribute elements while preserving the matrix structure.

Asked in

f Facebook 35 a Amazon 28 G Google 22 ⊞ Microsoft 15

The optimal approach uses the diagonal invariant property where all cells on the same diagonal share i - j = constant. We group elements by this key, sort each group, then redistribute them back to maintain the diagonal structure. This achieves O(m×n×log(min(m,n))) time complexity with clean, mathematical elegance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Extract, Sort, Replace)	O(mnlog(min(m,n)))	O(min(m,n))	Extract each diagonal individually, sort it, and put it back
Hash Map Grouping (Optimal)	O(mnlog(min(m,n)))	O(m*n)	Group elements by diagonal identifier (i-j) and sort each group

Brute Force (Extract, Sort, Replace) — Algorithm Steps

Identify all diagonal starting points (first row and first column)
For each starting point, extract all diagonal elements into a temporary array
Sort the temporary array in ascending order
Place the sorted elements back into their diagonal positions
Repeat for all diagonals

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Starting Points

Mark all diagonal starting points in first row and first column

Extract First Diagonal

Collect all elements from the first diagonal into a temporary array

Sort Extracted Elements

Sort the temporary array in ascending order

Replace in Matrix

Put the sorted elements back to their diagonal positions

Repeat Process

Continue for all remaining diagonals

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int** diagonalSort(int** mat, int matSize, int* matColSize, int* returnSize, int** returnColumnSizes) {
    int m = matSize, n = matColSize[0];
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        (*returnColumnSizes)[i] = n;
    }
    
    // Sort diagonals starting from first row
    for (int col = 0; col < n; col++) {
        int diagonal[200];
        int positions[200][2];
        int count = 0;
        
        // Extract diagonal
        int i = 0, j = col;
        while (i < m && j < n) {
            diagonal[count] = mat[i][j];
            positions[count][0] = i;
            positions[count][1] = j;
            count++;
            i++;
            j++;
        }
        
        // Sort and put back
        qsort(diagonal, count, sizeof(int), compare);
        for (int k = 0; k < count; k++) {
            int x = positions[k][0], y = positions[k][1];
            mat[x][y] = diagonal[k];
        }
    }
    
    // Sort diagonals starting from first column (except [0][0])
    for (int row = 1; row < m; row++) {
        int diagonal[200];
        int positions[200][2];
        int count = 0;
        
        // Extract diagonal
        int i = row, j = 0;
        while (i < m && j < n) {
            diagonal[count] = mat[i][j];
            positions[count][0] = i;
            positions[count][1] = j;
            count++;
            i++;
            j++;
        }
        
        // Sort and put back
        qsort(diagonal, count, sizeof(int), compare);
        for (int k = 0; k < count; k++) {
            int x = positions[k][0], y = positions[k][1];
            mat[x][y] = diagonal[k];
        }
    }
    
    return mat;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*log(min(m,n)))

We process each cell multiple times, and sort each diagonal (max length min(m,n))

⚡ Linearithmic

Space Complexity

O(min(m,n))

Extra space for storing one diagonal at a time during sorting

⚡ Linearithmic Space

52.4K Views

Medium Frequency

~15 min Avg. Time

2.2K 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 (Extract, Sort, Replace) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler