Repository: TheAlgorithms/Java
Pull request #3306 (2022-10-01 04:21:38)

Algorithm to search for an element in 2D Array.
The algorithm searches for an element in a 2D array sorted in both row & column manner. The algorithm's implemented over binary search. Added it's jUnit test too.

aitorfi: Could you add an interface similar to [SearchAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/devutils/searches/SearchAlgorithm.java) that can be used to search a matrix and implement it in your algorithm?
Shashwat79802: Actually haven't studied Interface yet, is it really necessary?
aitorfi: Alright I'll implement the interface once this PR is merged. One more thing, method names must be in cammelCase will you fix that please?
Shashwat79802: Made the changes you asked, and will make more if needed.

Patch:
diff --git a/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java b/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
new file mode 100644
index 00000000..e157dff2
--- /dev/null
+++ b/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
@@ -0,0 +1,37 @@
+package com.thealgorithms.searches;
+
+// The search is for any array which is sorted row and column-wise too. For ex :
+// int[][] arr = { {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 {
+
+    public static int[] search(int[][] matrix, int 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){
+
+            if (matrix[rowPointer][colPointer] == target)
+                return new int[] {rowPointer, colPointer};
+
+            else if (matrix[rowPointer][colPointer] < target)
+                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
+    }
+}


Test patch:
diff --git a/src/test/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearchTest.java b/src/test/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearchTest.java
new file mode 100644
index 00000000..3343c1ce
--- /dev/null
+++ b/src/test/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearchTest.java
@@ -0,0 +1,124 @@
+package com.thealgorithms.searches;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+public class RowColumnWiseSorted2dArrayBinarySearchTest {
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArrayBinarySearchTestMiddle() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 35;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {1,2};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(1, ans[0]);
+        assertEquals(2, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArrayBinarySearchTestSide() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 48;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {2,3};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(2, ans[0]);
+        assertEquals(3, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArray_BinarySearchTestUpper() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 20;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {0,1};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(0, ans[0]);
+        assertEquals(1, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArray_BinarySearchTestUpperSide() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 40;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {0,3};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(0, ans[0]);
+        assertEquals(3, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArray_BinarySearchTestLower() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 31;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {3,1};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(3, ans[0]);
+        assertEquals(1, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArray_BinarySearchTestLowerSide() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 51;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {3,3};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(3, ans[0]);
+        assertEquals(3, ans[1]);
+    }
+
+    @Test
+    // valid test case
+    public void rowColumnSorted2dArray_BinarySearchTestNotFound() {
+        int[][] arr = { {10, 20, 30, 40},
+                        {15, 25, 35, 45},
+                        {18, 28, 38, 48},
+                        {21, 31, 41, 51}
+                      };
+        int target = 101;
+        int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
+        int[] expected = {-1,-1};
+        System.out.println(Arrays.toString(ans));
+        assertEquals(-1, ans[0]);
+        assertEquals(-1, ans[1]);
+    }
+
+}