Skip to content

Search in a row wise and column wise sorted matrix

Last Updated : 22 Mar, 2025

Try it on GfG Practice

Given a matrix mat[][] and an integer x, the task is to check if x is present in mat[][] or not. Every row and column of the matrix is sorted in increasing order.

Examples:

Input: x = 62, mat[][] = [[3, 30, 38],
[20, 52, 54],
[35, 60, 69]]
Output: false
Explanation: 62 is not present in the matrix.

Input: x = 55, mat[][] = [[18, 21, 27],
[38, 55, 67]]
Output: true
Explanation: mat[1][1] is equal to 55.

Input: x = 35, mat[][] = [[3, 30, 38],
[20, 52, 54],
[35, 60, 69]]
Output: true
Explanation: mat[2][0] is equal to 35.

Table of Content

[Naive Approach] Comparing with all elements – O(n*m) Time and O(1) Space

The simple idea is to traverse the complete matrix and search for the target element. If the target element is found, return true. Otherwise, return false.

C++

// C++ program to search an element in row-wise // and column-wise sorted matrix   #include <iostream> #include <vector>  using namespace std;  bool matSearch(vector<vector<int>> &mat, int x) {     int n = mat.size(), m = mat[0].size();        // Iterate over all the elements to find x 	for(int i = 0; i < n; i++) {     	for(int j = 0; j < m; j++) {         	if(mat[i][j] == x)                 return true;         }     }        // If x was not found, return false     return false; }  int main() {     vector<vector<int>> mat = {{3, 30, 38},                                {20, 52, 54},                                {35, 60, 69}};     int x = 35;     if(matSearch(mat, x))          cout << "true";     else          cout << "false";     return 0; }

Java

// Java program to search an element in row-wise // and column-wise sorted matrix  class GfG {     static boolean matSearch(int[][] mat, int x) {         int n = mat.length, m = mat[0].length;                for(int i = 0; i < n; i++) {             for(int j = 0; j < m; j++) {                 if(mat[i][j] == x)                     return true;             }         }                // If x was not found, return false         return false;     }      public static void main(String[] args) {         int[][] mat = {{3, 30, 38},                        {20, 52, 54}, 					   {35, 60, 69}};         int x = 35;                  if(matSearch(mat, x))              System.out.println("true");         else              System.out.println("false");     } }

Python

# Python program to search an element in row-wise # and column-wise sorted matrix  def matSearch(mat, x):     n = len(mat)     m = len(mat[0])        for i in range(n):         for j in range(m):             if mat[i][j] == x:                 return True        # If x was not found, return false     return False  if __name__ == "__main__":     mat = [[3, 30, 38], 		   [20, 52, 54],            [35, 60, 69]]     x = 35     if matSearch(mat, x):         print("true")     else:         print("false")

C#

// C# program to search an element in row-wise // and column-wise sorted matrix  using System;  class GfG {     static bool matSearch(int[][] mat, int x) {         int n = mat.Length, m = mat[0].Length;          for (int i = 0; i < n; i++) {             for (int j = 0; j < m; j++) {                 if (mat[i][j] == x)                     return true;             }         }          // If x was not found, return false         return false;     }      static void Main() {         int[][] mat = new int[][] {             new int[] {3, 30, 38},             new int[] {20, 52, 54},             new int[] {35, 60, 69}         };         int x = 35;          if (matSearch(mat, x))             Console.WriteLine("true");         else             Console.WriteLine("false");     } }

JavaScript

// Java Script program to search an element in row-wise // and column-wise sorted matrix  function matSearch(mat, x) {     const n = mat.length, m = mat[0].length;      for (let i = 0; i < n; i++) {         for (let j = 0; j < m; j++) {             if (mat[i][j] === x)                 return true;         }     }      // If x was not found, return false     return false; }  // Driver Code const mat = [ [ 3, 30, 38 ],      		  [ 20, 52, 54 ],               [ 35, 60, 69 ] ]; const x = 35;  if (matSearch(mat, x))     console.log("true"); else     console.log("false");

Output

true

[Better Approach] Binary Search – O(n*logm) Time and O(1) Space:

To optimize the above approach we are going to use the Binary Search algorithm.
The problem specifies that each row in the given matrix is sorted in ascending order. Instead of searching each column sequentially, we can efficiently apply Binary Search on each row to determine if the target is present.

C++

// C++ program to search an element in row-wise // and column-wise sorted matrix  #include <iostream> #include <vector>  using namespace std;  bool binarySearch(vector<int> &mat, int target) {     int n = mat.size();     int low = 0, high = n - 1;      // Standard binary search algorithm     while (low <= high) {         int mid = (low + high) / 2;                  if (mat[mid] == target)              return true;  // Element found         else if (target > mat[mid])              low = mid + 1; // Search in the right half         else              high = mid - 1; // Search in the left half     }     return false;  // Element not found }  bool matSearch(vector<vector<int>> &mat, int x) {     int n = mat.size();      // Iterate over each row and perform binary search     for (int i = 0; i < n; i++) {         if (binarySearch(mat[i], x))              return true;  // Element found in one of the rows     }          return false;  // Element not found in any row }  int main() {     vector<vector<int>> mat = {{3, 30, 38},                                {20, 52, 54},                                {35, 60, 69}};     int x = 35;     if(matSearch(mat, x))          cout << "true";     else          cout << "false";     return 0; }

Java

// Java program to search an element in row-wise // and column-wise sorted matrix  class GfG {     public static boolean binarySearch(int[] mat, int target) {         int low = 0, high = mat.length - 1;          // Standard binary search algorithm         while (low <= high) {             int mid = (low + high) / 2;              if (mat[mid] == target)                  return true;  // Element found             else if (target > mat[mid])                  low = mid + 1; // Search in the right half             else                  high = mid - 1; // Search in the left half         }         return false;  // Element not found     }          static boolean matSearch(int[][] mat, int x) {         int n = mat.length; // Number of rows          // Iterate over each row and perform binary search         for (int i = 0; i < n; i++) {             if (binarySearch(mat[i], x))                  return true;  // Element found in one of the rows         }         return false;  // Element not found in any row     }      public static void main(String[] args) {         int[][] mat = {{3, 30, 38},                        {20, 52, 54}, 					   {35, 60, 69}};         int x = 35;                  if(matSearch(mat, x))              System.out.println("true");         else              System.out.println("false");     } }

Python

# Python program to search an element in row-wise # and column-wise sorted matrix  def binarySearch(mat, target):          n = len(mat)     low, high = 0, n - 1      # Standard binary search algorithm     while low <= high:         mid = (low + high) // 2  # Midpoint index          if mat[mid] == target:             return True  # Element found         elif target > mat[mid]:             low = mid + 1  # Search in the right half         else:             high = mid - 1  # Search in the left half      return False  # Element not found  def matSearch(mat, x):      n = len(mat)     m = len(mat[0])      # Iterate over each row and perform binary search     for i in range(n):         if binarySearch(mat[i], x):             return True  # Element found in one of the rows      return False  # Element not found in any row      if __name__ == "__main__":     mat = [         [3, 30, 38],         [20, 52, 54],         [35, 60, 69]     ]     x = 35     if matSearch(mat, x):         print("true")     else:         print("false")

C#

// C# program to search an element in row-wise // and column-wise sorted matrix   using System;  class GfG {          // Function to perform binary search on a sorted row (1D array)     static bool BinarySearch(int[] mat, int target)     {         int low = 0, high = mat.Length - 1;          // Standard binary search algorithm         while (low <= high)         {             int mid = (low + high) / 2;              if (mat[mid] == target)                 return true; // Element found             else if (target > mat[mid])                 low = mid + 1; // Search in the right half             else                 high = mid - 1; // Search in the left half         }         return false; // Element not found     }          // Function to search an element in a row-wise sorted matrix     static bool matSearch(int[][] mat, int x) {         int n = mat.Length;          // Iterate over each row and perform binary search         for (int i = 0; i < n; i++)         {             if (BinarySearch(mat[i], x))                 return true; // Element found in one of the rows         }          return false; // Element not found in any row     }      static void Main() {         int[][] mat = new int[][] {             new int[] {3, 30, 38},             new int[] {20, 52, 54},             new int[] {35, 60, 69}         };         int x = 35;          if (matSearch(mat, x))             Console.WriteLine("true");         else             Console.WriteLine("false");     } }

JavaScript

// JavaScript program to search an element in row-wise // and column-wise sorted matrix   function binarySearch(mat, target) {     let low = 0, high = mat.length - 1;      // Standard binary search algorithm     while (low <= high) {         let mid = Math.floor((low + high) / 2); // Use Math.floor() to get an integer index          if (mat[mid] === target)              return true;  // Element found         else if (target > mat[mid])              low = mid + 1; // Search in the right half         else              high = mid - 1; // Search in the left half     }     return false;  // Element not found }  function matSearch(mat, x) {     let n = mat.length;      // Iterate over each row and perform binary search     for (let i = 0; i < n; i++) {         if (binarySearch(mat[i], x))              return true;  // Element found in one of the rows     }          return false;  // Element not found in any row }  // Driver Code let mat = [     [3, 30, 38],     [20, 52, 54],     [35, 60, 69] ]; let x = 35;  if (matSearch(mat, x))     console.log("true"); else     console.log("false");

Output

true

[Expected Approach] Eliminating rows or columns – O(n + m) Time and O(1) Space:

The idea is to remove a row or column in each comparison until an element is found. Start searching from the top-right corner of the matrix. There are 3 possible cases:

x is greater than the current element: This ensures that all the elements in the current row are smaller than the given number as the pointer is already at the right-most element and the row is sorted. Thus, the entire row gets eliminated and continues the search from the next row.
x is smaller than the current element: This ensures that all the elements in the current column are greater than the given number. Thus, the entire column gets eliminated and continues the search from the previous column, i.e. the column on the immediate left.
The given number is equal to the current number: This will end the search.

Illustration:

C++

// C++ program to search an element in row-wise // and column-wise sorted matrix   #include <iostream> #include <vector>  using namespace std;  bool matSearch(vector<vector<int>> &mat, int x) {     int n = mat.size(), m = mat[0].size();     int i = 0, j = m - 1;        while(i < n && j >= 0) {                // If x > mat[i][j], then x will be greater         // than all elements to the left of          // mat[i][j] in row i, so increment i     	if(x > mat[i][j]) {         	i++;         }                // If x < mat[i][j], then x will be smaller         // than all elements to the bottom of         // mat[i][j] in column j, so decrement j         else if(x < mat[i][j]) {         	j--;         }                // If x = mat[i][j], return true         else {             return true;         }     }        // If x was not found, return false     return false; }  int main() {     vector<vector<int>> mat = {{3, 30, 38},                                {20, 52, 54},                                {35, 60, 69}};     int x = 35;     if(matSearch(mat, x))          cout << "true";     else          cout << "false";     return 0; }

Java

// Java program to search an element in row-wise // and column-wise sorted matrix  import java.util.*;  class GfG {     static boolean matSearch(int[][] mat, int x) {         int n = mat.length, m = mat[0].length;         int i = 0, j = m - 1;          while (i < n && j >= 0) {              // If x > mat[i][j], then x will be greater             // than all elements to the left of              // mat[i][j] in row i, so increment i             if (x > mat[i][j]) {                 i++;             }              // If x < mat[i][j], then x will be smaller             // than all elements to the bottom of             // mat[i][j] in column j, so decrement j             else if (x < mat[i][j]) {                 j--;             }              // If x = mat[i][j], return true             else {                 return true;             }         }          // If x was not found, return false         return false;     }      public static void main(String[] args) {         int[][] mat = {             {3, 30, 38},             {20, 52, 54},             {35, 60, 69}         };         int x = 35;          if (matSearch(mat, x))             System.out.println("true");         else             System.out.println("false");     } }

Python

# Python program to search an element in row-wise # and column-wise sorted matrix  def matSearch(mat, x):     n = len(mat)     m = len(mat[0])     i = 0     j = m - 1      while i < n and j >= 0:                # If x > mat[i][j], then x will be greater         # than all elements to the left of          # mat[i][j] in row i, so increment i         if x > mat[i][j]:             i += 1                # If x < mat[i][j], then x will be smaller         # than all elements to the bottom of         # mat[i][j] in column j, so decrement j         elif x < mat[i][j]:             j -= 1                # If x = mat[i][j], return true         else:             return True      # If x was not found, return false     return False  if __name__ == "__main__":     mat = [         [3, 30, 38],         [20, 52, 54],         [35, 60, 69]     ]     x = 35     if matSearch(mat, x):         print("true")     else:         print("false")

C#

// C# program to search an element in row-wise // and column-wise sorted matrix   using System;  class GfG {     static bool matSearch(int[][] mat, int x) {         int n = mat.Length, m = mat[0].Length;         int i = 0, j = m - 1;          while (i < n && j >= 0) {              // If x > mat[i][j], then x will be greater             // than all elements to the left of              // mat[i][j] in row i, so increment i             if (x > mat[i][j]) {                 i++;             }              // If x < mat[i][j], then x will be smaller             // than all elements to the bottom of             // mat[i][j] in column j, so decrement j             else if (x < mat[i][j]) {                 j--;             }              // If x = mat[i][j], return true             else {                 return true;             }         }          // If x was not found, return false         return false;     }      static void Main() {         int[][] mat = new int[][] {             new int[] {3, 30, 38},             new int[] {20, 52, 54},             new int[] {35, 60, 69}         };         int x = 35;          if (matSearch(mat, x))             Console.WriteLine("true");         else             Console.WriteLine("false");     } }

JavaScript

// JavaScript program to search an element in row-wise // and column-wise sorted matrix   function matSearch(mat, x) {     let n = mat.length, m = mat[0].length;     let i = 0, j = m - 1;      while (i < n && j >= 0) {          // If x > mat[i][j], then x will be greater         // than all elements to the left of          // mat[i][j] in row i, so increment i         if (x > mat[i][j]) {             i++;         }          // If x < mat[i][j], then x will be smaller         // than all elements to the bottom of         // mat[i][j] in column j, so decrement j         else if (x < mat[i][j]) {             j--;         }          // If x = mat[i][j], return true         else {             return true;         }     }      // If x was not found, return false     return false; }  // Driver Code let mat = [ 	[3, 30, 38],     [20, 52, 54], 	[35, 60, 69] ]; let x = 35;  if (matSearch(mat, x)) 	console.log("true"); else 	console.log("false");

Output

true

Related Article: Search element in a sorted matrix

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Linear Search Algorithm

Given an array, arr of n integers, and an integer element x, find whether element x is present in the array. Return the index of the first occurrence of x in the array, or -1 if it doesn't exist. Input: arr[] = [1, 2, 3, 4], x = 3Output: 2Explanation: There is one test case with array as [1, 2, 3 4]

What is Linear Search?

Linear search is defined as the searching algorithm where the list or data set is traversed from one end to find the desired value. Linear search works by sequentially checking each element in the list until the desired value is found or the end of the list is reached. Properties of Linear search :T

Recursive Linear Search Algorithm

Linear Search is defined as a sequential search algorithm that starts at one end and goes through each element of a list until the desired element is found, otherwise the search continues till the end of the data set. How Linear Search Works?Linear search works by comparing each element of the data

Sentinel Linear Search

Sentinel Linear Search as the name suggests is a type of Linear Search where the number of comparisons is reduced as compared to a traditional linear search. In a traditional linear search, only N comparisons are made, and in a Sentinel Linear Search, the sentinel value is used to avoid any out-of-b

Is Sentinel Linear Search better than normal Linear Search?

Sentinel Linear search is a type of linear search where the element to be searched is placed in the last position and then all the indices are checked for the presence of the element without checking for the index out of bound case. The number of comparisons is reduced in this search as compared to

Improving Linear Search Technique

A linear search or sequential search is a method for finding an element within a list. It sequentially checks each element of the list until a match is found or the whole list has been searched. It is observed that when searching for a key element, then there is a possibility for searching the same

Linear search using Multi-threading

Given a large file of integers, search for a particular element in it using multi-threading. Examples: Input : 1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220Output :if key = 20Key element foundInput :1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220Output :if key = 202Key