Skip to content
Related Articles

Related Articles

Search in a row wise and column wise sorted matrix
  • Difficulty Level : Medium
  • Last Updated : 03 Mar, 2021

Given an n x n matrix and a number x, find the position of x in the matrix if it is present in it. Otherwise, print “Not Found”. In the given matrix, every row and column is sorted in increasing order. The designed algorithm should have linear time complexity. 

Example: 

Input: mat[4][4] = { {10, 20, 30, 40},
                      {15, 25, 35, 45},
                      {27, 29, 37, 48},
                      {32, 33, 39, 50}};
              x = 29
Output: Found at (2, 1)
Explanation: Element at (2,1) is 29

Input : mat[4][4] = { {10, 20, 30, 40},
                      {15, 25, 35, 45},
                      {27, 29, 37, 48},
                      {32, 33, 39, 50}};
              x = 100
Output : Element not found
Explanation: Element 100 is not found

Simple Solution  

  • Approach: The simple idea is to traverse the array and to search element one by one.
  • Algorithm: 
    1. Run a nested loop, outer loop for row and inner loop for the column
    2. Check every element with x and if the element is found then print “element found”
    3. If the element is not found, then print “element not found”.
  • Implementation: 

CPP14




// C++ program to search an element in row-wise
// and column-wise sorted matrix
#include <bits/stdc++.h>
  
using namespace std;
  
/* Searches the element x in mat[][]. If the
element is found, then prints its position
and returns true, otherwise prints "not found"
and returns false */
int search(int mat[4][4], int n, int x)
{
    if (n == 0)
        return -1;
     
    //traverse through the matrix
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        //if the element is found
        if(mat[i][j] == x)
        {
            cout<<"Element found at ("<<
                        i << ", " << j << ")\n";
            return 1;
        }
    }
  
    cout << "n Element not found";
    return 0;
}
  
// Driver code
int main()
{
    int mat[4][4] = { { 10, 20, 30, 40 },
                      { 15, 25, 35, 45 },
                      { 27, 29, 37, 48 },
                      { 32, 33, 39, 50 } };
    search(mat, 4, 29);
  
    return 0;
}
Java



// Java program to search an element in row-wise
// and column-wise sorted matrix
 
class GFG {
  static int search(int[][] mat, int n, int x)
  {
    if (n == 0)
      return -1;
 
    // traverse through the matrix
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++)
        // if the element is found
        if (mat[i][j] == x) {
          System.out.print("Element found at ("
                           + i + ", " + j
                           + ")\n");
          return 1;
        }
    }
 
    System.out.print(" Element not found");
    return 0;
  }
  public static void main(String[] args)
  {
    int mat[][] = { { 10, 20, 30, 40 },
                   { 15, 25, 35, 45 },
                   { 27, 29, 37, 48 },
                   { 32, 33, 39, 50 } };
 
    search(mat, 4, 29);
  }
}
Python3



# Python program to search an element in row-wise
# and column-wise sorted matrix
 
# Searches the element x in mat[][]. If the
# element is found, then prints its position
# and returns true, otherwise prints "not found"
# and returns false
def search(mat, n, x):
    if(n == 0):
        return -1
     
    # Traverse through the matrix  
    for i in range(n):
        for j in range(n):
             
            # If the element is found
            if(mat[i][j] == x):
                print("Element found at (", i, ",", j, ")")
                return 1
     
    print(" Element not found")
    return 0
 
# Driver code
mat = [[10, 20, 30, 40], [15, 25, 35, 45],[27, 29, 37, 48],[32, 33, 39, 50]]
search(mat, 4, 29)
 
# This code is contributed by rag2127
C#



// C# program to search an element in row-wise
// and column-wise sorted matrix
using System;
 
class GFG{
 
/* Searches the element x in mat[][]. If the
element is found, then prints its position
and returns true, otherwise prints "not found"
and returns false */  
static int search(int[,] mat, int n, int x)
{
    if (n == 0)
        return -1;
     
    // Traverse through the matrix
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
         
        // If the element is found
        if (mat[i,j] == x)
        {
            Console.Write("Element found at (" + i +
                          ", " + j + ")\n");
            return 1;
        }
    }
    Console.Write(" Element not found");
    return 0;
}
 
// Driver code
static public void Main()
{
    int[,] mat = { { 10, 20, 30, 40 },
                   { 15, 25, 35, 45 },
                   { 27, 29, 37, 48 },
                   { 32, 33, 39, 50 } };
                    
    search(mat, 4, 29);
}
}
 
// This code is contributed by avanitrachhadiya2155
Output
Element found at (2, 1)
A better solution is to use Divide and Conquer to find the element which has a time complexity of O(n1.58). Please refer here for details.


Efficient Solution 
  • Approach: The simple 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 three possible cases. 
    1. The given number is greater than the current number: This will ensure, 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 continue the search on the next row. Here elimination means that row needs not to be searched.
    2. The given number is smaller than the current number: This will ensure, that all the elements in the current column are greater than the given number. Thus, the entire column gets eliminated and continue the search on the previous column i.e. the column at the immediate left.
    3. The given number is equal to the current number: This will end the search.
  • Algorithm: 
    1. Let the given element be x, create two variable i = 0, j = n-1 as index of row and column
    2. Run a loop until i = 0
    3. Check if the current element is greater than x then decrease the count of j. Exclude the current column.
    4. Check if the current element is less than x then increase the count of i. Exclude the current row.
    5. If the element is equal then print the position and end.
  • Thanks to devendraiiit for suggesting the below approach.
  • Implementation:
C++



// C++ program to search an element in row-wise
// and column-wise sorted matrix
#include <bits/stdc++.h>
 
using namespace std;
 
/* Searches the element x in mat[][]. If the
element is found, then prints its position
and returns true, otherwise prints "not found"
and returns false */
int search(int mat[4][4], int n, int x)
{
    if (n == 0)
        return -1;
   
    int smallest = mat[0][0], largest = mat[n - 1][n - 1];
    if (x < smallest || x > largest)
        return -1;
   
    // set indexes for top right element
    int i = 0, j = n - 1;
    while (i < n && j >= 0)
    {
        if (mat[i][j] == x)
        {
            cout << "n Found at "
                 << i << ", " << j;
            return 1;
        }
        if (mat[i][j] > x)
            j--;
       
        // Check if mat[i][j] < x
        else
            i++;
    }
 
    cout << "n Element not found";
    return 0;
}
 
// Driver code
int main()
{
    int mat[4][4] = { { 10, 20, 30, 40 },
                      { 15, 25, 35, 45 },
                      { 27, 29, 37, 48 },
                      { 32, 33, 39, 50 } };
    search(mat, 4, 29);
 
    return 0;
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)
C



// C program to search an element in row-wise
// and column-wise sorted matrix
#include <stdio.h>
 
/* Searches the element x in mat[][]. If the
element is found, then prints its position
and returns true, otherwise prints "not found"
and returns false */
int search(int mat[4][4], int n, int x)
{
    if (n == 0)
        return -1;
    int smallest = mat[0][0], largest = mat[n - 1][n - 1];
    if (x < smallest || x > largest)
        return -1;
   
    // set indexes for top right element
    int i = 0, j = n - 1;
    while (i < n && j >= 0)
    {
        if (mat[i][j] == x)
        {
            printf("\n Found at %d, %d", i, j);
            return 1;
        }
        if (mat[i][j] > x)
            j--;
        else // if mat[i][j] < x
            i++;
    }
 
    printf("n Element not found");
    return 0; // if ( i==n || j== -1 )
}
 
// driver program to test above function
int main()
{
    int mat[4][4] = {
        { 10, 20, 30, 40 },
        { 15, 25, 35, 45 },
        { 27, 29, 37, 48 },
        { 32, 33, 39, 50 },
    };
    search(mat, 4, 29);
    return 0;
}
Java



// JAVA Code for Search in a row wise and
// column wise sorted matrix
 
class GFG {
 
    /* Searches the element x in mat[][]. If the
    element is found, then prints its position
    and returns true, otherwise prints "not found"
    and returns false */
    private static void search(int[][] mat,
                                    int n, int x)
    {
         
        // set indexes for top right
        int i = 0, j = n - 1;
        // element
 
        while (i < n && j >= 0)
        {
            if (mat[i][j] == x)
            {
                System.out.print("n Found at " +
                                    i + " " + j);
                return;
            }
            if (mat[i][j] > x)
                j--;
            else // if mat[i][j] < x
                i++;
        }
 
        System.out.print("n Element not found");
        return; // if ( i==n || j== -1 )
    }
    // driver program to test above function
    public static void main(String[] args)
    {
        int mat[][] = { { 10, 20, 30, 40 },
                        { 15, 25, 35, 45 },
                        { 27, 29, 37, 48 },
                        { 32, 33, 39, 50 } };
 
        search(mat, 4, 29);
    }
}
// This code is contributed by Arnav Kr. Mandal.
Python3



# Python3 program to search an element
# in row-wise and column-wise sorted matrix
 
# Searches the element x in mat[][]. If the
# element is found, then prints its position
# and returns true, otherwise prints "not found"
# and returns false
def search(mat, n, x):
 
    i = 0
     
    # set indexes for top right element
    j = n - 1
    while ( i < n and j >= 0 ):
     
        if (mat[i][j] == x ):
     
            print("n Found at ", i, ", ", j)
            return 1
     
        if (mat[i][j] > x ):
            j -= 1
             
        # if mat[i][j] < x
        else:
            i += 1
     
    print("Element not found")
    return 0 # if (i == n || j == -1 )
 
# Driver Code
mat = [ [10, 20, 30, 40],
        [15, 25, 35, 45],
        [27, 29, 37, 48],
        [32, 33, 39, 50] ]
search(mat, 4, 29)
 
# This code is contributed by Anant Agarwal.
C#



// C# Code for Search in a row wise and
// column wise sorted matrix
using System;
 
class GFG
{
    /* Searches the element x in mat[][]. If the
    element is found, then prints its position
    and returns true, otherwise prints "not found"
    and returns false */
    private static void search(int[, ] mat,
                               int n, int x)
    {
        // set indexes for top right
        // element
        int i = 0, j = n - 1;
 
        while (i < n && j >= 0)
        {
            if (mat[i, j] == x)
            {
                Console.Write("n Found at "
                              + i + ", " + j);
                return;
            }
 
            if (mat[i, j] > x)
                j--;
            else // if mat[i][j] < x
                i++;
        }
 
        Console.Write("n Element not found");
        return; // if ( i==n || j== -1 )
    }
    // driver program to test above function
    public static void Main()
    {
 
        int[, ] mat = { { 10, 20, 30, 40 },
                        { 15, 25, 35, 45 },
                        { 27, 29, 37, 48 },
                        { 32, 33, 39, 50 } };
 
        search(mat, 4, 29);
    }
}
 
// This code is contributed by Sam007
PHP



<?php
// PHP program to search an
// element in row-wise and
// column-wise sorted matrix
 
/* Searches the element $x
in mat[][]. If the element is
found, then prints its position
and returns true, otherwise prints
"not found" and returns false */
function search(&$mat, $n, $x)
{
    $i = 0;
    $j = $n - 1; // set indexes for
                // top right element
    while ($i < $n && $j >= 0)
    {
        if ($mat[$i][$j] == $x)
        {
            echo "n found at " . $i.
                        ", " . $j;
            return 1;
        }
        if ($mat[$i][$j] > $x)
            $j--;
        else // if $mat[$i][$j] < $x
            $i++;
    }
     
    echo "n Element not found";
    return 0; // if ( $i==$n || $j== -1 )
}
 
// Driver Code
$mat = array(array(10, 20, 30, 40),
            array(15, 25, 35, 45),
            array(27, 29, 37, 48),
            array(32, 33, 39, 50));
search($mat, 4, 29);
 
// This code is contributed
// by ChitraNayal
?>
Output
n Found at 2, 1
Time Complexity: O(n). 
Only one traversal is needed, i.e, i from 0 to n and j from n-1 to 0 with at most 2*n steps. 
The above approach will also work for m x n matrix (not only for n x n). Complexity would be O(m + n). 
Space Complexity: O(1). 
No extra space is required.
https://youtu.be/_reu46LJtyk
 
Related Article : 
Search element in a sorted matrix
Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.
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.
My Personal Notes
arrow_drop_up
Previous
Search element in a sorted matrix
Next

Inplace rotate square matrix by 90 degrees | Set 1
Recommended Articles
Page :
Maximum sum of any submatrix of a Matrix which is sorted row-wise and column-wise
10, Aug 20
Largest row-wise and column-wise sorted sub-matrix
08, Jan 20
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
heapq in Python to print all elements in sorted order from row and column wise sorted matrix
07, Nov 17
Print all elements in sorted order from row and column wise sorted matrix
22, Oct 14
Check if a grid can become row-wise and column-wise sorted after adjacent swaps
06, Sep 17
Kth smallest element in a row-wise and column-wise sorted 2D array | Set 1
16, Apr 14
Sort the matrix row-wise and column-wise
27, Jan 18
Row-wise vs column-wise traversal of matrix
14, Feb 18
Count number of islands where every island is row-wise and column-wise separated
27, Feb 15
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix
07, May 20
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix | Set 2
09, May 20
Check if the given matrix is increasing row and column wise
21, May 19
Removing row or column wise duplicates from matrix of characters
22, Jan 18
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
Find median in row wise sorted matrix
15, Jul 17
Find a common element in all rows of a given row-wise sorted matrix
13, Feb 15
Search in a sorted 2D matrix (Stored in row major order)
12, Nov 18
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
Row-wise common elements in two diagonals of a square matrix
02, Oct 17
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
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





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