A

```
package com.thealgorithms.searches;
import com.thealgorithms.devutils.searches.MatrixSearchAlgorithm;
/**
* The search is for any array which is sorted row and column-wise too. For ex :
* {{10, 20, 30, 40},
* {15, 25, 35, 45},
* {18, 28, 38, 48},
* {21, 31, 41, 51}}
*
* This array is sorted in both row and column manner.
* In this two pointers are taken, the first points to the 0th row and the second one points to end
* column, and then the element corresponding to the pointers placed in the array is compared with
* the target that either its equal, greater or smaller than the target. If the element is equal to
* the target, the co-ordinates of that element is returned i.e. an array of the two pointers will
* be returned, else if the target is greater than corresponding element then the pointer pointing
* to the 0th row will be incremented by 1, else if the target is lesser than the corresponding
* element then the pointer pointing to the end column will be decremented by 1. And if the element
* doesn't exist in the array, an array
* {-1, -1} will be returned.
*/
public class RowColumnWiseSorted2dArrayBinarySearch implements MatrixSearchAlgorithm {
@Override
public <T extends Comparable<T>> int[] find(T[][] matrix, T key) {
return search(matrix, key);
}
public static <T extends Comparable<T>> int[] search(T[][] matrix, T target) {
int rowPointer = 0; // The pointer at 0th row
int colPointer = matrix.length - 1; // The pointer at end column
while (rowPointer < matrix.length && colPointer >= 0) {
int comp = target.compareTo(matrix[rowPointer][colPointer]);
if (comp == 0) {
return new int[] {rowPointer, colPointer};
} else if (comp > 0) {
rowPointer++; // Incrementing the row pointer if the target is greater
} else {
colPointer--; // Decrementing the column pointer if the target is lesser
}
}
return new int[] {-1, -1}; // The not found condition
}
}
```