Searching an element in a 2D sorted array

Question

I had to write a code (as an exercise) that receives a 2D (square) row wise and col wise sorted array and an element, and return true is the element exists in the array.

The first thing that came to mind when i heard "sorted" is binary search, but than i realized that the last element in each row isn't necessarily smaller than the first one in the next line.

So, i figured out that the best complexity will be O(n), and wrote the following code:

 public static boolean findN(int[][] a, int x) {
    if (a.length == 0 || a[0].length == 0 || x > a[a.length - 1][a[0].length - 1] || x < a[0][0]) {
        return false;
    }
    int LastRow = a.length - 1, Lastcol = a[0].length - 1, row = 0, col = 0;

    while (row <= LastRow) {
        if (a[row][col] == x) {
            return true;
        } else if (col < Lastcol) {
            col++;
        } else {
            col = 0;
            row++;
        }
    }
    return false;
}

array example:

int [] [] arr = {{1,2,7,30}
                        {2,4,18,50}
                        {3,6,19,90}
                        {4,7,20,91}}

• After realizing that the best complexity will be O(n), I googled this problem so I'm almost certain that I'm right (although some people are claiming that they can do it in O(log(n))), but am I really?
• Any other thoughts and improvements are welcomed, thank you all in advance!

Answer 1

I came across a similar problem a few months ago and here is the code I found that works in O(logN + logM) [assuming the array is sorted row-wise as well as column-wise].

[...] but than i realized that the last element in each row isn't necessarily smaller than the first one in the next line. - In this case, you cannot achieve O(logn) complexity.

Simple Binary Search:

static void binarySearch(int mat[][], int i, int j_low, int j_high, int x) { 
    while (j_low <= j_high) { 
        int j_mid = (j_low + j_high) / 2; 

        // Element found 
        if (mat[i][j_mid] == x) { 
            System.out.println ( "Found at (" + i  + ", " + j_mid +")"); 
            return; 
        } 

        else if (mat[i][j_mid] > x) 
            j_high = j_mid - 1; 

        else
            j_low = j_mid + 1; 
    } 

    System.out.println ( "Element no found"); 
} 

Core Logic:

static void sortedMatrixSearch(int mat[][], int n, int m, int x) { 
    // Single row matrix 
    if (n == 1) { 
        binarySearch(mat, 0, 0, m - 1, x); 
        return; 
    } 

    // Do binary search in middle column. 
    // Condition to terminate the loop when the 
    // 2 desired rows are found 
    int i_low = 0; 
    int i_high = n - 1; 
    int j_mid = m / 2; 
    while ((i_low + 1) < i_high) { 
        int i_mid = (i_low + i_high) / 2; 

        // element found 
        if (mat[i_mid][j_mid] == x) { 
            System.out.println ( "Found at (" + i_mid +", " + j_mid +")"); 
            return; 
        } 

        else if (mat[i_mid][j_mid] > x) 
            i_high = i_mid; 

        else
            i_low = i_mid; 
    } 

    // If element is present on  
    // the mid of the two rows 
    if (mat[i_low][j_mid] == x) 
        System.out.println ( "Found at (" + i_low + "," + j_mid +")"); 
    else if (mat[i_low + 1][j_mid] == x) 
        System.out.println ( "Found at (" + (i_low + 1)  + ", " + j_mid +")"); 

    // Ssearch element on 1st half of 1st row 
    else if (x <= mat[i_low][j_mid - 1]) 
        binarySearch(mat, i_low, 0, j_mid - 1, x); 

    // Search element on 2nd half of 1st row 
    else if (x >= mat[i_low][j_mid + 1] && x <= mat[i_low][m - 1]) 
    binarySearch(mat, i_low, j_mid + 1, m - 1, x); 

    // Search element on 1st half of 2nd row 
    else if (x <= mat[i_low + 1][j_mid - 1]) 
        binarySearch(mat, i_low + 1, 0, j_mid - 1, x); 

    // search element on 2nd half of 2nd row 
    else
        binarySearch(mat, i_low + 1, j_mid + 1, m - 1, x); 
} 

Driver method:

public static void main (String[] args) { 
    int n = 4, m = 5, x = 8; 
    int mat[][] = {{0, 6, 8, 9, 11}, 
                   {20, 22, 28, 29, 31}, 
                   {36, 38, 50, 61, 63}, 
                   {64, 66, 100, 122, 128}}; 

    sortedMatrixSearch(mat, n, m, x); 
} 

Hope this helps. Good luck.