Sort Matrix by Diagonals

Sort Matrix by Diagonals - Problem

You are given an n × n square matrix of integers grid. Your task is to return the matrix such that:

• The diagonals in the bottom-left triangle (including the middle diagonal) are sorted in non-increasing order (descending)

• The diagonals in the top-right triangle are sorted in non-decreasing order (ascending)

Each diagonal is a line of cells where the difference between row and column indices remains constant.

Input & Output

Example 1 — Basic 3×3 Matrix

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

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

💡 Note: Bottom-left diagonals [4], [2,2] sorted descending stay the same. Main diagonal [3,2,2] sorted descending stays [3,2,2]. Top-right diagonals [3,1], [1] sorted ascending become [1,3], [1].

Example 2 — Larger Matrix

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

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

💡 Note: Bottom-left: [1], [4,8], [7,3,9] sorted descending become [1], [8,4], [9,7,3]. Top-right: [6,2], [5] sorted ascending become [2,6], [5]. Result has properly sorted diagonals.

Example 3 — Already Sorted

$ Input: grid = [[5,4],[3,2]]

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

💡 Note: Bottom-left diagonal [5,2] sorted descending stays [5,2]. Main diagonal contains only [5] at (0,0) and [2] at (1,1), giving [5,2] descending. Top-right diagonal [4] stays [4]. Cross-diagonal [3] stays [3].

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 100
1 ≤ grid[i][j] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is that diagonals can be identified by the value (row - col), with negative values for top-right triangle and non-negative for bottom-left triangle. Best approach extracts each diagonal, sorts according to triangle rules (ascending for top-right, descending for bottom-left), then places back. Time: O(n² log n), Space: O(n²)

Common Approaches

✓ Extract and Sort Each Diagonal

⏱️ Time: O(n² log n) Space: O(n²)

Identify each diagonal by the difference (row - column), extract elements, sort based on triangle position, then reconstruct the matrix.

In-Place Diagonal Sorting

⏱️ Time: O(n² log n) Space: O(n)

Process each diagonal individually by collecting elements along the diagonal, sorting them, then immediately placing them back to reduce memory usage.

Extract and Sort Each Diagonal — Algorithm Steps

Step 1: For each possible diagonal (identified by row - col), extract all elements
Step 2: Sort each diagonal - descending for bottom-left triangle, ascending for top-right
Step 3: Place sorted elements back into their diagonal positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Diagonals

Group elements by (row - col) value

Sort Each Diagonal

Sort based on triangle position

Reconstruct Matrix

Place sorted elements back

Code -

solution.c — C

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

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

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

static int diagonals[199][100];  // Max 2*100-1 diagonals
static int diagonal_sizes[199];
static int diagonal_indices[199];

int** solution(int** grid, int n, int* returnSize, int** returnColumnSizes) {
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        (*returnColumnSizes)[i] = n;
    }
    
    // Initialize
    memset(diagonal_sizes, 0, sizeof(diagonal_sizes));
    memset(diagonal_indices, 0, sizeof(diagonal_indices));
    
    // Extract diagonals
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int key = i - j + n - 1; // Shift to positive index
            diagonals[key][diagonal_sizes[key]++] = grid[i][j];
        }
    }
    
    // Sort each diagonal
    for (int k = 0; k < 2*n-1; k++) {
        int original_key = k - n + 1;
        if (original_key > 0) {
            qsort(diagonals[k], diagonal_sizes[k], sizeof(int), compare_desc);
        } else if (original_key == 0) {
            qsort(diagonals[k], diagonal_sizes[k], sizeof(int), compare_desc);
        } else {
            qsort(diagonals[k], diagonal_sizes[k], sizeof(int), compare_asc);
        }
    }
    
    // Create result matrix
    int** result = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Place back
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int key = i - j + n - 1;
            result[i][j] = diagonals[key][diagonal_indices[key]++];
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON parsing for 2D array
    int n = 0;
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') n++;
        ptr++;
    }
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse numbers
    ptr = line;
    int row = 0, col = 0;
    char* endptr;
    
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
            long val = strtol(ptr, &endptr, 10);
            grid[row][col] = (int)val;
            col++;
            if (col == n) {
                col = 0;
                row++;
            }
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(grid, n, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", result[i][j]);
            if (j < n-1) printf(",");
        }
        printf("]");
        if (i < n-1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Visit each cell once to extract O(n²), sort n diagonals of average length n/2 giving O(n² log n)

⚠ Quadratic Growth

Space Complexity

O(n²)

Store all diagonal elements in separate arrays before sorting

⚠ Quadratic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Extract and Sort Each Diagonal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler