From 38285771c8bf1e4bf1c3741d4ce397d744b01136 Mon Sep 17 00:00:00 2001
From: Hardik Pawar <97388607+Hardvan@users.noreply.github.com>
Date: Fri, 11 Oct 2024 01:21:06 +0530
Subject: [PATCH] Add tests, remove main in JumpSearch (#5669)
---
DIRECTORY.md | 1 +
.../thealgorithms/searches/JumpSearch.java | 55 ++++++-----
.../searches/JumpSearchTest.java | 94 +++++++++++++++++++
3 files changed, 128 insertions(+), 22 deletions(-)
create mode 100644 src/test/java/com/thealgorithms/searches/JumpSearchTest.java
diff --git a/DIRECTORY.md b/DIRECTORY.md
index ff6e29806..a22863e8b 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1007,6 +1007,7 @@
* [InterpolationSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java)
* [IterativeBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/IterativeBinarySearchTest.java)
* [IterativeTernarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/IterativeTernarySearchTest.java)
+ * [JumpSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/JumpSearchTest.java)
* [KMPSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/KMPSearchTest.java)
* [OrderAgnosticBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/OrderAgnosticBinarySearchTest.java)
* [PerfectBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/PerfectBinarySearchTest.java)
diff --git a/src/main/java/com/thealgorithms/searches/JumpSearch.java b/src/main/java/com/thealgorithms/searches/JumpSearch.java
index f499cf807..8dcec3a81 100644
--- a/src/main/java/com/thealgorithms/searches/JumpSearch.java
+++ b/src/main/java/com/thealgorithms/searches/JumpSearch.java
@@ -2,44 +2,55 @@ package com.thealgorithms.searches;
import com.thealgorithms.devutils.searches.SearchAlgorithm;
+/**
+ * An implementation of the Jump Search algorithm.
+ *
+ *
+ * Jump Search is an algorithm for searching sorted arrays. It works by dividing the array
+ * into blocks of a fixed size (the block size is typically the square root of the array length)
+ * and jumping ahead by this block size to find a range where the target element may be located.
+ * Once the range is found, a linear search is performed within that block.
+ *
+ *
+ * The Jump Search algorithm is particularly effective for large sorted arrays where the cost of
+ * performing a linear search on the entire array would be prohibitive.
+ *
+ *
+ * Worst-case performance: O(√N)
+ * Best-case performance: O(1)
+ * Average performance: O(√N)
+ * Worst-case space complexity: O(1)
+ *
+ *
+ * This class implements the {@link SearchAlgorithm} interface, providing a generic search method
+ * for any comparable type.
+ */
public class JumpSearch implements SearchAlgorithm {
- public static void main(String[] args) {
- JumpSearch jumpSearch = new JumpSearch();
- Integer[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
- for (int i = 0; i < array.length; i++) {
- assert jumpSearch.find(array, i) == i;
- }
- assert jumpSearch.find(array, -1) == -1;
- assert jumpSearch.find(array, 11) == -1;
- }
-
/**
- * Jump Search algorithm implements
+ * Jump Search algorithm implementation.
*
- * @param array the array contains elements
- * @param key to be searched
- * @return index of {@code key} if found, otherwise -1
+ * @param array the sorted array containing elements
+ * @param key the element to be searched
+ * @return the index of {@code key} if found, otherwise -1
*/
@Override
public > int find(T[] array, T key) {
int length = array.length;
- /* length of array */
int blockSize = (int) Math.sqrt(length);
- /* block size to be jumped */
int limit = blockSize;
- while (key.compareTo(array[limit]) > 0 && limit < array.length - 1) {
- limit = Math.min(limit + blockSize, array.length - 1);
+ // Jumping ahead to find the block where the key may be located
+ while (limit < length && key.compareTo(array[limit]) > 0) {
+ limit = Math.min(limit + blockSize, length - 1);
}
- for (int i = limit - blockSize; i <= limit; i++) {
- if (array[i] == key) {
- /* execute linear search */
+ // Perform linear search within the identified block
+ for (int i = limit - blockSize; i <= limit && i < length; i++) {
+ if (array[i].equals(key)) {
return i;
}
}
return -1;
- /* not found */
}
}
diff --git a/src/test/java/com/thealgorithms/searches/JumpSearchTest.java b/src/test/java/com/thealgorithms/searches/JumpSearchTest.java
new file mode 100644
index 000000000..3fa319b66
--- /dev/null
+++ b/src/test/java/com/thealgorithms/searches/JumpSearchTest.java
@@ -0,0 +1,94 @@
+package com.thealgorithms.searches;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the JumpSearch class.
+ */
+class JumpSearchTest {
+
+ /**
+ * Test for finding an element present in the array.
+ */
+ @Test
+ void testJumpSearchFound() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ Integer key = 5; // Element to find
+ assertEquals(5, jumpSearch.find(array, key), "The index of the found element should be 5.");
+ }
+
+ /**
+ * Test for finding the first element in the array.
+ */
+ @Test
+ void testJumpSearchFirstElement() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ Integer key = 0; // First element
+ assertEquals(0, jumpSearch.find(array, key), "The index of the first element should be 0.");
+ }
+
+ /**
+ * Test for finding the last element in the array.
+ */
+ @Test
+ void testJumpSearchLastElement() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ Integer key = 10; // Last element
+ assertEquals(10, jumpSearch.find(array, key), "The index of the last element should be 10.");
+ }
+
+ /**
+ * Test for finding an element not present in the array.
+ */
+ @Test
+ void testJumpSearchNotFound() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ Integer key = -1; // Element not in the array
+ assertEquals(-1, jumpSearch.find(array, key), "The element should not be found in the array.");
+ }
+
+ /**
+ * Test for finding an element in an empty array.
+ */
+ @Test
+ void testJumpSearchEmptyArray() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = {}; // Empty array
+ Integer key = 1; // Key not present
+ assertEquals(-1, jumpSearch.find(array, key), "The element should not be found in an empty array.");
+ }
+
+ /**
+ * Test for finding an element in a large array.
+ */
+ @Test
+ void testJumpSearchLargeArray() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = new Integer[1000];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i * 2; // Fill the array with even numbers
+ }
+ Integer key = 256; // Present in the array
+ assertEquals(128, jumpSearch.find(array, key), "The index of the found element should be 128.");
+ }
+
+ /**
+ * Test for finding an element in a large array when it is not present.
+ */
+ @Test
+ void testJumpSearchLargeArrayNotFound() {
+ JumpSearch jumpSearch = new JumpSearch();
+ Integer[] array = new Integer[1000];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i * 2; // Fill the array with even numbers
+ }
+ Integer key = 999; // Key not present
+ assertEquals(-1, jumpSearch.find(array, key), "The element should not be found in the array.");
+ }
+}