Median of a Row Wise Sorted Matrix - Practice Coding Problems

Median of a Row Wise Sorted Matrix - Problem

Given an m x n matrix where each row is sorted in non-decreasing order and contains an odd total number of integers, your task is to find the median of all elements in the matrix.

The median is the middle value when all elements are arranged in sorted order. Since the total count is odd, there will always be exactly one median value.

Important: You must solve this problem in less than O(m × n) time complexity, which means you cannot simply extract all elements and sort them.

Example: In a 3×3 matrix with 9 elements, the median would be the 5th smallest element when all 9 elements are conceptually sorted.

Input & Output

example_1.py — Basic 3x3 Matrix

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

› Output: 6

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

example_2.py — Single Row Matrix

$ Input: matrix = [[1,2,3,4,5]]

› Output: 3

💡 Note: In a single row with 5 elements, the median is the middle element at index 2, which is 3.

example_3.py — Single Column Matrix

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

› Output: 2

💡 Note: In a single column with 3 elements, the median is the middle element, which is 2.

Visualization

Tap to expand

Understanding the Visualization

Identify Range

Note the smallest and largest page counts across all shelves

Make a Guess

Pick a middle value for potential median page count

Count Efficiently

For each shelf, quickly count books with ≤ guessed pages using shelf organization

Adjust Guess

If too few books counted, guess higher; if too many, guess lower

Converge

Repeat until finding the exact median page count

Key Takeaway

🎯 Key Insight: Since rows are pre-sorted, we can efficiently count elements smaller than any value using binary search, enabling us to binary search on the answer itself rather than sorting all elements.

Time & Space Complexity

Time Complexity

⏱️

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

Binary search on answer space: log(max-min) iterations, each taking O(m * log(n)) to count elements

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search, no extra arrays needed

✓ Linear Space

Constraints

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

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24 Apple 18

The optimal approach uses binary search on the answer space combined with binary search on each row to count elements efficiently. Instead of collecting all elements (which violates time constraints), we binary search for the median value directly, achieving O(m × log(n) × log(range)) time complexity while using only O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(m * log(n) * log(max-min))	O(1)	Binary search on the possible median values while counting smaller elements efficiently
Brute Force (Collect All Elements)	O(mn log(mn))	O(mn)	Extract all elements, sort them, and find the middle element

Binary Search on Answer (Optimal) — Algorithm Steps

Find the minimum and maximum possible values in the matrix
Binary search between min and max values
For each candidate value, count elements ≤ candidate using binary search on each row
If count ≥ (total+1)/2, try smaller values; otherwise try larger values
Return the final answer when search space is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Search Space

Set left=min_element, right=max_element

Pick Candidate

Choose mid value between left and right

Count Elements

Use binary search on each row to count elements ≤ mid

Adjust Search

Move left or right based on count comparison with target

Code -

solution.c — C

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

int countSmallerEqual(int** matrix, int m, int n, int target) {
    int count = 0;
    for (int i = 0; i < m; i++) {
        int left = 0, right = n - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (matrix[i][mid] <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        count += left;
    }
    return count;
}

int findMedian(int** matrix, int m, int n) {
    int left = matrix[0][0];
    int right = matrix[m-1][n-1];
    int targetCount = (m * n + 1) / 2;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        int count = countSmallerEqual(matrix, m, n, mid);
        
        if (count < targetCount) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return left;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

Binary search on answer space: log(max-min) iterations, each taking O(m * log(n)) to count elements

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search, no extra arrays needed

✓ Linear Space

Constraints

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

52.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Binary Search on Answer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler