Sort the Matrix Diagonally

Sort the Matrix Diagonally - Problem

A matrix diagonal is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until reaching the matrix's end.

For example, the matrix diagonal starting from mat[2][0], where mat is a 6 x 3 matrix, includes cells mat[2][0], mat[3][1], and mat[4][2].

Given an m x n matrix mat of integers, sort each matrix diagonal in ascending order and return the resulting matrix.

Input & Output

Example 1 — Basic 3x3 Matrix

$ 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: Main diagonal [3,2,1] becomes [1,2,3]. Diagonal starting at [0,1]: [3,2,1] becomes [1,2,3]. Each diagonal is sorted independently while maintaining structure.

Example 2 — Rectangular Matrix

$ 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: Each diagonal is sorted independently. The main diagonal [11,55,36,25,5] becomes [5,11,25,36,55].

Example 3 — Single Row

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

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

💡 Note: Each element forms its own diagonal, so no sorting is needed. Matrix remains unchanged.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 35 a Amazon 28 G Google 22 M Microsoft 18

The key insight is that all cells on the same diagonal share the same (row - col) value. We can group elements by this coordinate difference, sort each group, then redistribute back. Best approach uses coordinate mapping with Time: O(m×n×log(min(m,n))), Space: O(m×n).

Common Approaches

✓ Coordinate Mapping

⏱️ Time: O(m×n×log(min(m,n))) Space: O(m×n)

Recognize that all cells on the same diagonal have the same (row - col) value. Group elements by this key into a map, sort each group, then distribute back to the matrix in the same diagonal order.

Extract, Sort, Replace

⏱️ Time: O(m×n×log(min(m,n))) Space: O(min(m,n))

For each diagonal starting from the top row and left column, extract all values into a temporary array, sort the array, then place the sorted values back into the matrix along the same diagonal.

Coordinate Mapping — Algorithm Steps

Group elements by (row - col) coordinate
Sort each group separately
Redistribute sorted elements back to matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Keys

Each cell gets key = row - col

Group & Sort

Elements with same key form one diagonal

Redistribute

Place sorted values back by key order

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define MAX_DIAGONALS 2000

static struct Diagonal {
    int elements[MAX_SIZE];
    int size;
} diagonals[MAX_DIAGONALS];

static int indices[MAX_DIAGONALS];
static int mat[MAX_SIZE][MAX_SIZE];
static int matColSize[MAX_SIZE];

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

int** solution(int** matrix, int matSize, int* matColSizes, int* returnSize, int** returnColumnSizes) {
    *returnSize = matSize;
    *returnColumnSizes = (int*)malloc(matSize * sizeof(int));
    for (int i = 0; i < matSize; i++) {
        (*returnColumnSizes)[i] = matColSizes[i];
    }
    
    if (matSize == 0 || matColSizes[0] == 0) return matrix;
    
    int m = matSize, n = matColSizes[0];
    
    // Initialize diagonals
    for (int i = 0; i < MAX_DIAGONALS; i++) {
        diagonals[i].size = 0;
        indices[i] = 0;
    }
    
    // Group elements by diagonal (row - col)
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int key = i - j + MAX_SIZE; // Offset to make positive index
            diagonals[key].elements[diagonals[key].size++] = matrix[i][j];
        }
    }
    
    // Sort each diagonal
    for (int k = 0; k < MAX_DIAGONALS; k++) {
        if (diagonals[k].size > 0) {
            qsort(diagonals[k].elements, diagonals[k].size, sizeof(int), compare);
        }
    }
    
    // Place sorted elements back
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int key = i - j + MAX_SIZE;
            matrix[i][j] = diagonals[key].elements[indices[key]++];
        }
    }
    
    return matrix;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
    }
    
    // Parse 2D array manually
    int rows = 0;
    char *ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr && *ptr != ']') {
        // Find start of inner array
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr || *ptr != '[') break;
        ptr++; // skip '['
        
        int cols = 0;
        while (*ptr && *ptr != ']') {
            // Skip whitespace and commas
            while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
            if (*ptr && *ptr != ']') {
                mat[rows][cols++] = strtol(ptr, &ptr, 10);
                matColSize[rows] = cols;
            }
        }
        if (*ptr == ']') ptr++; // skip ']'
        rows++;
        
        // Skip comma between arrays
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    // Create matrix pointers
    int** matrix = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = mat[i];
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(matrix, rows, matColSize, &returnSize, &returnColumnSizes);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(matrix);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

One pass to group O(m×n), sorting all diagonals O(m×n×log(min(m,n)))

⚡ Linearithmic

Space Complexity

O(m×n)

Hash map stores all matrix elements grouped by diagonal

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Coordinate Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler