Median of a Row Wise Sorted Matrix - Problem

Given an m x n matrix grid containing an odd number of integers where each row is sorted in non-decreasing order, return the median of the matrix.

You must solve the problem in less than O(m * n) time complexity.

Note: The median is the middle element when all elements are sorted in ascending order. Since the matrix contains an odd number of elements, there will always be exactly one median element.

Input & Output

Example 1 — Basic 3x3 Matrix

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

› Output: 5

💡 Note: Sorted elements: [1,2,3,3,5,6,6,9,9]. The median (middle element at index 4) is 5.

Example 2 — Different Values

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

› Output: 5

💡 Note: All elements in order: [1,2,3,4,5,6,7,8,9]. The median is the middle element 5 at index 4.

Example 3 — Repeated Values

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

› Output: 3

💡 Note: Sorted: [1,1,2,2,3,3,3,3,3]. The median at position 4 (0-indexed) is 3.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 500
m * n is odd
1 ≤ grid[i][j] ≤ 10⁶
grid[i] is sorted in non-decreasing order

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 18 f Facebook 15

The key insight is to binary search on the answer space rather than positions. Since we need better than O(m*n), we avoid collecting all elements. The optimal approach uses binary search on value range [min, max] and counts elements ≤ each candidate. Time: O(m * log(max-min) * log n), Space: O(1).

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(m * log(max-min) * log n) Space: O(1)

Instead of sorting all elements, binary search on the range of possible values. For each candidate value, count how many matrix elements are ≤ candidate. The median is the smallest value where at least half the elements are ≤ it.

Collect All Elements and Sort

⏱️ Time: O(m*n*log(m*n)) Space: O(m*n)

Extract all elements from the matrix into a single array, sort the array, and return the element at the middle position. This straightforward approach ignores the sorted row property.

Binary Search on Answer Space — Algorithm Steps

Find min and max values in matrix
Binary search on value range [min, max]
For each mid value, count elements ≤ mid across all rows
Adjust search based on count vs required median position

Visualization

Tap to expand

Step-by-Step Walkthrough

Value Range

Find min=1, max=9 from matrix corners

Binary Search

Try middle value (5) and count elements ≤ 5

Count & Decide

5 elements ≤ 5, which is median position, so answer is 5

Code -

solution.c — C

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

int countLessEqual(int** grid, int gridSize, int* gridColSize, int target) {
    int count = 0;
    for (int i = 0; i < gridSize; i++) {
        int left = 0, right = gridColSize[i];
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (grid[i][mid] <= target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        count += left;
    }
    return count;
}

int solution(int** grid, int gridSize, int* gridColSize) {
    int totalElements = 0;
    for (int i = 0; i < gridSize; i++) {
        totalElements += gridColSize[i];
    }
    int medianPos = totalElements / 2;
    
    // Find min and max values
    int minVal = INT_MAX, maxVal = INT_MIN;
    for (int i = 0; i < gridSize; i++) {
        if (grid[i][0] < minVal) minVal = grid[i][0];
        if (grid[i][gridColSize[i]-1] > maxVal) maxVal = grid[i][gridColSize[i]-1];
    }
    
    // Binary search on answer
    int left = minVal, right = maxVal;
    
    while (left < right) {
        int mid = (left + right) / 2;
        if (countLessEqual(grid, gridSize, gridColSize, mid) <= medianPos) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return left;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array
    int** grid = malloc(100 * sizeof(int*));
    int* gridColSize = malloc(100 * sizeof(int));
    int gridSize = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        if (*p == '[') {
            char rowStr[1000];
            int len = 0;
            while (*p && *p != ']') {
                rowStr[len++] = *p++;
            }
            if (*p == ']') {
                rowStr[len++] = *p++;
                rowStr[len] = '\0';
                
                grid[gridSize] = malloc(100 * sizeof(int));
                parseArray(rowStr, grid[gridSize], &gridColSize[gridSize]);
                gridSize++;
            }
        } else {
            p++;
        }
    }
    
    int result = solution(grid, gridSize, gridColSize);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * log(max-min) * log n)

For each of log(max-min) binary search iterations, we do m binary searches on rows of size n

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

~25 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

Median of a Row Wise Sorted Matrix - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler