# LeetCode – Search a 2D Matrix (Java)

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has properties:

1) Integers in each row are sorted from left to right. 2) The first integer of each row is greater than the last integer of the previous row.

For example, consider the following matrix:

```[
[1,   3,  5,  7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
```

Given target = 3, return true.

Java Solution

This is a typical problem of binary search.

You may try to solve this problem by finding the row first and then the column. There is no need to do that. Because of the matrix's special features, the matrix can be considered as a sorted array. The goal is to find the element in this sorted array by using binary search.

```public class Solution { public boolean searchMatrix(int[][] matrix, int target) { if(matrix==null || matrix.length==0 || matrix.length==0) return false;   int m = matrix.length; int n = matrix.length;   int start = 0; int end = m*n-1;   while(start<=end){ int mid=(start+end)/2; int midX=mid/n; int midY=mid%n;   if(matrix[midX][midY]==target) return true;   if(matrix[midX][midY]<target){ start=mid+1; }else{ end=mid-1; } }   return false; } }```
Category >> Algorithms
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
```<pre><code>
String foo = "bar";
</code></pre>
```
• Alik Elzin

Referring to the matrix as a large array is an elegant solution. Love it.

• saipabbathi

The first row max element should not be more than the second row small element. Your test casee is wrong.

• Murali

It has a bug for this input [[1,4],[2,5]]. Target = 2. Returns false

• Blake

Just saw a condition: “The first integer of each row is greater than the last integer of the previous row.” The test case shouldnt exist. This solution is correct!

• Blake

It has a bug if the target number is larger than pivot; however, it is at left-hand side of flattened array. Ex:
[[1,3,5,17],[10,11,16,20],[23,30,34,50]]
17
expected: true

• sachin

There is a O(n) approch i.e left bottom

package com.substring;

public class Bed {

public static void main(String[] ar) {
int a[][] = { { 1, 3, 5, 7 }, { 10, 11, 16, 20 }, { 23, 30, 34, 50 } };
System.out.println(findMatrix(a, 11));
}

public static boolean findMatrix(int[][] matrix, int target) {
int left = matrix.length – 1;
int down = 0;

while (left > 0 && down <= matrix.length-1) {
System.out.println(target +" | "+matrix[down][left]);

if (target matrix[down][left]) {
down++;
}
if (target == matrix[down][left])
return true;
}

return false;
}

}

how could that be?

• Maya

Check first element and last element helps to eliminate unnecessary binary search

if(target matrix[m-1][n-1]) return false;

• RJ

Can end also be m*n?

• amsan7

By iterating through all the rows our solution becomes O(m), while the provided solution is O(lg(mn))

• Doug Pase

A binary search across the entire array becomes more difficult if the matrix is sparse, such as a skyline matrix. In those cases it’s better to find the row (binary search) first, then the column (also binary search). The time complexity is the same when the matrix is square and dense, but it also works when the matrix has different length rows.

• Vikrant Mishra

Why is there a need to even perform a binary search if we just want to return a boolean. Since each row is sorted we can just compare whether our element is greater than the first element and less than the last element of a particular row and return true. If not we iterate through all the rows and keep checking for the aforementioned condition.

• Bach

Just want to point out that the time complexity for both your approach and “finding the row first and then the column” approach should be log(mn).