Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find median in row wise sorted matrix

  • Difficulty Level : Hard
  • Last Updated : 25 Sep, 2021

We are given a row-wise sorted matrix of size r*c, we need to find the median of the matrix given. It is assumed that r*c is always odd.
Examples: 

Input : 1 3 5
        2 6 9
        3 6 9
Output : Median is 5
If we put all the values in a sorted 
array A[] = 1 2 3 3 5 6 6 9 9)

Input: 1 3 4
       2 5 6
       7 8 9
Output: Median is 5

Simple Method: The simplest method to solve this problem is to store all the elements of the given matrix in an array of size r*c. Then we can either sort the array and find the median element in O(r*clog(r*c)) or we can use the approach discussed here to find the median in O(r*c). Auxiliary space required will be O(r*c) in both cases.
An efficient approach for this problem is to use a binary search algorithm. The idea is that for a number to be median there should be exactly (n/2) numbers which are less than this number. So, we try to find the count of numbers less than all the numbers. Below is the step by step algorithm for this approach: 
Algorithm:  

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

  1. First, we find the minimum and maximum elements in the matrix. The minimum element can be easily found by comparing the first element of each row, and similarly, the maximum element can be found by comparing the last element of each row.
  2. Then we use binary search on our range of numbers from minimum to maximum, we find the mid of the min and max and get a count of numbers less than or equal to our mid. And accordingly change the min or max.
  3. For a number to be median, there should be (r*c)/2 numbers smaller than that number. So for every number, we get the count of numbers less than that by using upper_bound() in each row of the matrix, if it is less than the required count, the median must be greater than the selected number, else the median must be less than or equal to the selected number.

Below is the implementation of the above approach:
 



C++




// C++ program to find median of a matrix
// sorted row wise
#include<bits/stdc++.h>
using namespace std;
 
const int MAX = 100;
 
// function to find median in the matrix
int binaryMedian(int m[][MAX], int r ,int c)
{
    int min = INT_MAX, max = INT_MIN;
    for (int i=0; i<r; i++)
    {
        // Finding the minimum element
        if (m[i][0] < min)
            min = m[i][0];
 
        // Finding the maximum element
        if (m[i][c-1] > max)
            max = m[i][c-1];
    }
 
    int desired = (r * c + 1) / 2;
    while (min < max)
    {
        int mid = min + (max - min) / 2;
        int place = 0;
 
        // Find count of elements smaller than mid
        for (int i = 0; i < r; ++i)
            place += upper_bound(m[i], m[i]+c, mid) - m[i];
        if (place < desired)
            min = mid + 1;
        else
            max = mid;
    }
    return min;
}
 
// driver program to check above functions
int main()
{
    int r = 3, c = 3;
    int m[][MAX]= { {1,3,5}, {2,6,9}, {3,6,9} };
    cout << "Median is " << binaryMedian(m, r, c) << endl;
    return 0;
}
Java



// Java program to find median of a matrix
// sorted row wise
import java.util.Arrays;
 
public class MedianInRowSorted
{
    // function to find median in the matrix
    static int binaryMedian(int m[][],int r, int c)
    {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
         
        for(int i=0; i<r ; i++)
        {
             
            // Finding the minimum element
            if(m[i][0] < min)
                min = m[i][0];
             
            // Finding the maximum element
            if(m[i][c-1] > max)
                max = m[i][c-1];
        }
         
        int desired = (r * c + 1) / 2;
        while(min < max)
        {
            int mid = min + (max - min) / 2;
            int place = 0;
            int get = 0;
             
            // Find count of elements smaller than mid
            for(int i = 0; i < r; ++i)
            {
                 
                get = Arrays.binarySearch(m[i],mid);
                 
                // If element is not found in the array the
                // binarySearch() method returns
                // (-(insertion_point) - 1). So once we know
                // the insertion point we can find elements
                // Smaller than the searched element by the
                // following calculation
                if(get < 0)
                    get = Math.abs(get) - 1;
                 
                // If element is found in the array it returns
                // the index(any index in case of duplicate). So we go to last
                // index of element which will give  the number of
                // elements smaller than the number including
                // the searched element.
                else
                {
                    while(get < m[i].length && m[i][get] == mid)
                        get += 1;
                }
                 
                place = place + get;
            }
             
            if (place < desired)
                min = mid + 1;
            else
                max = mid;
        }
        return min;
    }
     
    // Driver Program to test above method.
    public static void main(String[] args)
    {
        int r = 3, c = 3;
        int m[][]= { {1,3,5}, {2,6,9}, {3,6,9} };
         
        System.out.println("Median is " + binaryMedian(m, r, c));
    }
}
 
// This code is contributed by Sumit Ghosh
Python3



# Python program to find median of matrix
# sorted row wise
 
from bisect import bisect_right as upper_bound
 
MAX = 100;
 
# Function to find median in the matrix
def binaryMedian(m, r, d):
    mi = m[0][0]
    mx = 0
    for i in range(r):
        if m[i][0] < mi:
            mi = m[i][0]
        if m[i][d-1] > mx :
            mx =  m[i][d-1]
     
    desired = (r * d + 1) // 2
     
    while (mi < mx):
        mid = mi + (mx - mi) // 2
        place = [0];
         
        # Find count of elements smaller than mid
        for i in range(r):
             j = upper_bound(m[i], mid)
             place[0] = place[0] + j
        if place[0] < desired:
            mi = mid + 1
        else:
            mx = mid
    print ("Median is", mi)
    return   
     
# Driver code
r, d = 3, 3
 
m = [ [1, 3, 5], [2, 6, 9], [3, 6, 9]]
binaryMedian(m, r, d)
 
# This code is contributed by Sachin BIsht
C#



// C# program to find median
// of a matrix sorted row wise
using System;
class MedianInRowSorted{
 
// Function to find median
// in the matrix
static int binaryMedian(int [,]m,
                        int r, int c)
{
  int max = int.MinValue;
  int min = int.MaxValue;
 
  for(int i = 0; i < r; i++)
  {
    // Finding the minimum
    // element
    if(m[i, 0] < min)
      min = m[i, 0];
 
    // Finding the maximum
    // element
    if(m[i, c - 1] > max)
      max = m[i, c - 1];
  }
 
  int desired = (r * c + 1) / 2;
  while(min < max)
  {
    int mid = min + (max - min) / 2;
    int place = 0;
    int get = 0;
 
    // Find count of elements
    // smaller than mid
    for(int i = 0; i < r; ++i)
    {
      get = Array.BinarySearch(
            GetRow(m, i), mid);
 
      // If element is not found
      // in the array the binarySearch()
      // method returns (-(insertion_
      // point) - 1). So once we know
      // the insertion point we can
      // find elements Smaller than
      // the searched element by the
      // following calculation
      if(get < 0)
        get = Math.Abs(get) - 1;
 
      // If element is found in the
      // array it returns the index(any
      // index in case of duplicate). So
      // we go to last index of element
      // which will give  the number of
      // elements smaller than the number
      // including the searched element.
      else
      {
        while(get < GetRow(m, i).GetLength(0) &&
              m[i, get] == mid)
          get += 1;
      }
 
      place = place + get;
    }
 
    if (place < desired)
      min = mid + 1;
    else
      max = mid;
  }
  return min;
}
 
public static int[] GetRow(int[,] matrix,
                           int row)
{
  var rowLength = matrix.GetLength(1);
  var rowVector = new int[rowLength];
 
  for (var i = 0; i < rowLength; i++)
    rowVector[i] = matrix[row, i];
 
  return rowVector;
}
   
// Driver code
public static void Main(String[] args)
{
  int r = 3, c = 3;
  int [,]m = {{1,3,5},
              {2,6,9},
              {3,6,9} };
 
  Console.WriteLine("Median is " +
                     binaryMedian(m, r, c));
}
}
 
// This code is contributed by Princi Singh
Javascript



<script>
 
// Javascript program to find median
// of a matrix sorted row wise
 
 
// Function to find median
// in the matrix
function binaryMedian(m, r, c)
{
  var max = -1000000000;
  var min = 1000000000;
 
  for(var i = 0; i < r; i++)
  {
    // Finding the minimum
    // element
    if(m[i][0] < min)
      min = m[i][0];
 
    // Finding the maximum
    // element
    if(m[i] > max)
      max = m[i];
  }
 
  var desired =  parseInt((r * c + 1) / 2);
  while(min < max)
  {
    var mid = min + parseInt((max - min) / 2);
    var place = 0;
    var get = 0;
 
    // Find count of elements
    // smaller than mid
    for(var i = 0; i < r; ++i)
    {
        var tmp = GetRow(m, i);
        for(var j = tmp.length; j>=0; j--)
        {
            if(tmp[j] <= mid)
            {
                get = j+1;
                break;
            }
        }
 
      // If element is not found
      // in the array the binarySearch()
      // method returns (-(insertion_
      // point) - 1). So once we know
      // the insertion point we can
      // find elements Smaller than
      // the searched element by the
      // following calculation
      if(get < 0)
        get = Math.abs(get) - 1;
 
      // If element is found in the
      // array it returns the index(any
      // index in case of duplicate). So
      // we go to last index of element
      // which will give  the number of
      // elements smaller than the number
      // including the searched element.
      else
      {
        while(get < GetRow(m, i).length &&
              m[i][get] == mid)
          get += 1;
      }
 
      place = place + get;
    }
 
    if (place < desired)
      min = mid + 1;
    else
      max = mid;
  }
  return min;
}
 
function GetRow(matrix, row)
{
  var rowLength = matrix[0].length;
  var rowVector = Array(rowLength).fill(0);
 
  for (var i = 0; i < rowLength; i++)
    rowVector[i] = matrix[row][i];
 
  return rowVector;
}
   
// Driver code
var r = 3, c = 3;
var m = [[1,3,5],
            [2,6,9],
            [3,6,9]];
document.write("Median is " +
                   binaryMedian(m, r, c));
 
 
// This code is contributed by rutvik_56.
</script>
Output
Median is 5

Time Complexity: O(32 * r * log(c)). The upper bound function will take log(c) time and is performed for each row. And since the numbers will be max of 32 bit, so binary search of numbers from min to max will be performed in at most 32 ( log2(2^32) = 32 ) operations. 
Auxiliary Space : O(1) 
 
?list=PLqM7alHXFySGNyLyr8A2CBEBIbUIEC38f
This article is contributed by Akshit Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
 



My Personal Notes
arrow_drop_up
Previous
Median of two sorted arrays of different sizes | Set 1 (Linear)
Next

Matrix Multiplication | Recursive
Recommended Articles
Page :
Count Negative Numbers in a Column-Wise and Row-Wise Sorted Matrix
17, Mar 16
Count zeros in a row wise and column wise sorted matrix
20, Jul 16
Maximum sum of any submatrix of a Matrix which is sorted row-wise and column-wise
10, Aug 20
Search in a row wise and column wise sorted matrix
10, Mar 11
Largest row-wise and column-wise sorted sub-matrix
08, Jan 20
Kth smallest element in a row-wise and column-wise sorted 2D array | Set 1
16, Apr 14
Check if a grid can become row-wise and column-wise sorted after adjacent swaps
06, Sep 17
Sort the matrix row-wise and column-wise
27, Jan 18
Row-wise vs column-wise traversal of matrix
14, Feb 18
Print all elements in sorted order from row and column wise sorted matrix
22, Oct 14
heapq in Python to print all elements in sorted order from row and column wise sorted matrix
07, Nov 17
Count number of islands where every island is row-wise and column-wise separated
27, Feb 15
Find a common element in all rows of a given row-wise sorted matrix
13, Feb 15
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix | Set 2
09, May 20
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix
07, May 20
Row-wise common elements in two diagonals of a square matrix
02, Oct 17
Removing row or column wise duplicates from matrix of characters
22, Jan 18
Shift matrix elements row-wise by k
27, Mar 18
Program to print elements of a Matrix row-wise skipping alternate elements
09, Oct 18
Check if the given matrix is increasing row and column wise
21, May 19
Find Median for each Array element by excluding the index at which Median is calculated
04, Aug 21
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Row wise sorting in 2D array
18, Jan 18
Check if any row of the matrix can be converted to the elements present in the target row
19, Oct 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!