Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add an interface for matrix search algorithms (closes #3461) (#3464)

Browse Source
This commit is contained in:
Aitor Fidalgo Sánchez 2022-10-09 13:45:36 +02:00 committed by GitHub
parent cce1dbd124
commit 03a4832a7d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 152 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/main/java/com/thealgorithms/devutils/searches/MatrixSearchAlgorithm.java Normal file
View File

@ -0,0 +1,16 @@
package com.thealgorithms.devutils.searches;
/**
* The common interface of most searching algorithms that search in matrixes.
*
* @author Aitor Fidalgo (https://github.com/aitorfi)
*/
public interface MatrixSearchAlgorithm {
/**
* @param key is an element which should be found
* @param matrix is a matrix where the element should be found
* @param <T> Comparable type
* @return array containing the first found coordinates of the element
*/
<T extends Comparable<T>> int[] find(T matrix[][], T key);
}

65
src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
View File

@ -1,37 +1,46 @@
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.
import com.thealgorithms.devutils.searches.MatrixSearchAlgorithm;
public class RowColumnWiseSorted2dArrayBinarySearch {
/**
* 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 {
public static int[] search(int[][] matrix, int target) {
@Override
public <T extends Comparable<T>> int[] find(T[][] matrix, T key) {
return search(matrix, key);
}
int rowPointer = 0; //The pointer at 0th row
int colPointer = matrix.length-1; //The pointer at end column
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){
while (rowPointer < matrix.length && colPointer >= 0) {
int comp = target.compareTo(matrix[rowPointer][colPointer]);
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
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
}
}

209
src/test/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearchTest.java
View File

@ -1,124 +1,113 @@
package com.thealgorithms.searches;
import org.junit.jupiter.api.Test;
import java.util.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
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
public void rowColumnSorted2dArrayBinarySearchTestMiddle() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 35;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 1, 2 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[1], 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
public void rowColumnSorted2dArrayBinarySearchTestSide() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 48;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 2, 3 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[1], 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
public void rowColumnSorted2dArray_BinarySearchTestUpper() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 20;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 0, 1 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[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
public void rowColumnSorted2dArray_BinarySearchTestUpperSide() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 40;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 0, 3 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[1], 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
public void rowColumnSorted2dArray_BinarySearchTestLower() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 31;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 3, 1 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[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]);
}
@Test
public void rowColumnSorted2dArray_BinarySearchTestLowerSide() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 51;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { 3, 3 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[1], ans[1]);
}
@Test
public void rowColumnSorted2dArray_BinarySearchTestNotFound() {
Integer[][] arr = {
{ 10, 20, 30, 40 },
{ 15, 25, 35, 45 },
{ 18, 28, 38, 48 },
{ 21, 31, 41, 51 },
};
Integer target = 101;
int[] ans = RowColumnWiseSorted2dArrayBinarySearch.search(arr, target);
int[] expected = { -1, -1 };
assertEquals(expected[0], ans[0]);
assertEquals(expected[1], ans[1]);
}
}