Search in a Row-wise and Column-wise Sorted 2D Array using Divide and Conquer algorithm

Last Updated : 24 Apr, 2025

Given an n x n matrix, where every row and column is sorted in increasing order. Given a key, how to decide whether this key is in the matrix.

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 = 30, mat[][] = [[3, 30],
[20, 52]],
Output: true
Explanation: mat[0][1] is equal to 30.

We have discussed Naive, Binary Search Based and then a Linear Time solution in Search in a row wise and column wise sorted matrix

This problem can also be a very good example for divide and conquer algorithms. Following is divide and conquer algorithm.
1) Find the middle element.
2) If middle element is same as key return.
3) If middle element is lesser than key then
.......3a) search submatrix on lower side of middle element
.......3b) Search submatrix on right hand side.of middle element
4) If middle element is greater than key then
......4a) search vertical submatrix on left side of middle element
......4b) search submatrix on right hand side.

DaCMat3

Following implementation of above algorithm.

C++

#include <iostream>
#include <vector>
using namespace std;

// A divide and conquer method to search a given key in mat[]
// in rows from fromRow to toRow and columns from fromCol to toCol
bool search(const vector<vector<int>>& mat, int fromRow, int toRow,
            int fromCol, int toCol, int key)
{
    if (fromRow > toRow || fromCol > toCol)
        return false;

    int i = fromRow + (toRow - fromRow) / 2;
    int j = fromCol + (toCol - fromCol) / 2;

    if (mat[i][j] == key) {
        return true;
    }

    // Right-up quarter (Always Searched)
    if ((i != toRow || j != fromCol) && 
        search(mat, fromRow, i, j, toCol, key))
        return true;

    // Special case for 1x2 matrix
    if (fromRow == toRow && fromCol + 1 == toCol) {
        if (mat[fromRow][toCol] == key)
            return true;
    }

    if (mat[i][j] < key) {
        
        // Search lower horizontal
        return (i + 1 <= toRow && search(mat, i + 1, toRow, fromCol, toCol, key));
         
    } else {
        
        // Search left vertical
        return (j - 1 >= fromCol && search(mat, fromRow, toRow, fromCol, j - 1, key));
    }

    return false;
}

// Driver code
int main() {
    vector<vector<int>> mat = {
        {10, 20, 30, 40},
        {15, 25, 35, 45},
        {27, 29, 37, 48},
        {32, 33, 39, 50}
    };

    int key = 50;

    if (search(mat, 0, mat.size() - 1, 0, mat[0].size() - 1, key))
        cout << "Key " << key << " found\n";
    else
        cout << "Key " << key << " not found\n";

    return 0;
}

Java

// A divide and conquer method to search a given key in mat[]
// in rows from fromRow to toRow and columns from fromCol to toCol
public class MatrixSearch {
    public static boolean search(int[][] mat, int fromRow, int toRow,
                                  int fromCol, int toCol, int key) {
        if (fromRow > toRow || fromCol > toCol)
            return false;

        int i = fromRow + (toRow - fromRow) / 2;
        int j = fromCol + (toCol - fromCol) / 2;

        if (mat[i][j] == key) {
            return true;
        }

        // Right-up quarter (Always Searched)
        if ((i != toRow || j != fromCol) && 
            search(mat, fromRow, i, j, toCol, key))
            return true;

        // Special case for 1x2 matrix
        if (fromRow == toRow && fromCol + 1 == toCol) {
            if (mat[fromRow][toCol] == key)
                return true;
        }

        if (mat[i][j] < key) {
            
            // Search lower horizontal
            return (i + 1 <= toRow && search(mat, i + 1, toRow, fromCol, toCol, key));
        } else {
            
            // Search left vertical
            return (j - 1 >= fromCol && search(mat, fromRow, toRow, fromCol, j - 1, key));
        }

        return false;
    }

    // Driver code
    public static void main(String[] args) {
        int[][] mat = {
            {10, 20, 30, 40},
            {15, 25, 35, 45},
            {27, 29, 37, 48},
            {32, 33, 39, 50}
        };

        int key = 50;

        if (search(mat, 0, mat.length - 1, 0, mat[0].length - 1, key))
            System.out.println("Key " + key + " found");
        else
            System.out.println("Key " + key + " not found");
    }
}

Python

# A divide and conquer method to search a given key in mat[]
# in rows from fromRow to toRow and columns from fromCol to toCol
def search(mat, fromRow, toRow, fromCol, toCol, key):
    if fromRow > toRow or fromCol > toCol:
        return False

    i = fromRow + (toRow - fromRow) // 2
    j = fromCol + (toCol - fromCol) // 2

    if mat[i][j] == key:
        return True

    # Right-up quarter (Always Searched)
    if (i != toRow or j != fromCol) and search(mat, fromRow, i, j, toCol, key):
        return True

    # Special case for 1x2 matrix
    if fromRow == toRow and fromCol + 1 == toCol:
        if mat[fromRow][toCol] == key:
            return True

    if mat[i][j] < key:
        # Search lower horizontal
        return (i + 1 <= toRow and search(mat, i + 1, toRow, fromCol, toCol, key))
    else:
        # Search left vertical
        return (j - 1 >= fromCol and search(mat, fromRow, toRow, fromCol, j - 1, key))

    return False

# Driver code
mat = [
    [10, 20, 30, 40],
    [15, 25, 35, 45],
    [27, 29, 37, 48],
    [32, 33, 39, 50]
]

key = 50

if search(mat, 0, len(mat) - 1, 0, len(mat[0]) - 1, key):
    print(f"Key {key} found")
else:
    print(f"Key {key} not found")

JavaScript

// A divide and conquer method to search a given key in mat[]
// in rows from fromRow to toRow and columns from fromCol to toCol
function search(mat, fromRow, toRow, fromCol, toCol, key) {
    if (fromRow > toRow || fromCol > toCol) {
        return false;
    }

    let i = Math.floor((fromRow + toRow) / 2);
    let j = Math.floor((fromCol + toCol) / 2);

    if (mat[i][j] === key) {
        return true;
    }

    // Right-up quarter (Always Searched)
    if (!(i === toRow && j === fromCol) && search(mat, fromRow, i, j, toCol, key)) {
        return true;
    }

    // Special case for 1x2 matrix
    if (fromRow === toRow && fromCol + 1 === toCol) {
        if (mat[fromRow][toCol] === key) {
            return true;
        }
    }

    if (mat[i][j] < key) {
        // Search lower horizontal
        return (i + 1 <= toRow && search(mat, i + 1, toRow, fromCol, toCol, key));
    } else {
        // Search left vertical
        return (j - 1 >= fromCol && search(mat, fromRow, toRow, fromCol, j - 1, key));
    }

    return false;
}

// Driver code
let mat = [
    [10, 20, 30, 40],
    [15, 25, 35, 45],
    [27, 29, 37, 48],
    [32, 33, 39, 50]
];

let key = 50;

if (search(mat, 0, mat.length - 1, 0, mat[0].length - 1, key)) {
    console.log(`Key ${key} found`);
} else {
    console.log(`Key ${key} not found`);
}

Output

Found 10 at 0 0
Found 20 at 0 1
Found 30 at 0 2
Found 40 at 0 3
Found 15 at 1 0
Found 25 at 1 1
Found 35 at 1 2
Found 45 at 1 3
Found 27 at 2 0
Found 29 at 2 1
Found 37 at 2 2
Found 48 at 2 3
Found 32 at 3 0
Found 33 at 3 1
Found 39 at 3 2
Found 50 at 3 3

Time complexity:
We are given a n*n matrix, the algorithm can be seen as recurring for 3 matrices of size n/2 x n/2. Following is recurrence for time complexity

 T(n) = 3T(n/2) + O(1)

Space Complexity: O(log(n))

The solution of recurrence is O(n1.58) using Master Method.
But the actual implementation calls for one submatrix of size n x n/2 or n/2 x n, and other submatrix of size n/2 x n/2.

Allocate Minimum Pages

Kaushik Lele

Improve

Article Tags :

Practice Tags :

Search in a Row-wise and Column-wise Sorted 2D Array using Divide and Conquer algorithm

Similar Reads

Some standard Divide and Conquer Algorithms

Binary Search based problems

Some practice problems on Divide and Conquer algorithm

Thank You!

What kind of Experience do you want to share?