Merge branch 'master' into fix/fibonacci-search-out-of-bounds

Author: DenizAltunkapan

src/main/java/com/thealgorithms/searches/ExponentialSearch.java

@@ -46,6 +46,9 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
             range = range * 2;
         }
 
-        return Arrays.binarySearch(array, range / 2, Math.min(range, array.length), key);
+        // The candidate block is the inclusive index range [range / 2, range], so the
+        // exclusive upper bound handed to binarySearch has to be range + 1.
+        final int index = Arrays.binarySearch(array, range / 2, Math.min(range + 1, array.length), key);
+        return index >= 0 ? index : -1;
     }
 }

src/main/java/com/thealgorithms/searches/JumpSearch.java

@@ -73,7 +73,7 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
         int limit = blockSize;
         // 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);
+            limit += blockSize;
         }
 
         // Perform linear search within the identified block

src/test/java/com/thealgorithms/searches/ExponentialSearchTest.java

@@ -81,4 +81,46 @@ void testExponentialSearchLargeArray() {
         int expectedIndex = 9999;
         assertEquals(expectedIndex, exponentialSearch.find(array, key), "The index of the last element should be 9999.");
     }
+
+    /**
+     * An element sitting exactly on the doubling boundary used to be reported as missing, because
+     * the binary search was handed {@code range} as its exclusive upper bound instead of
+     * {@code range + 1}.
+     */
+    @Test
+    void testExponentialSearchElementOnRangeBoundary() {
+        ExponentialSearch exponentialSearch = new ExponentialSearch();
+        Integer[] array = {-25, -9, 8, 21};
+        assertEquals(2, exponentialSearch.find(array, 8), "The index of the found element should be 2.");
+    }
+
+    /**
+     * Every element must be found regardless of the array length.
+     */
+    @Test
+    void testExponentialSearchFindsEveryElement() {
+        ExponentialSearch exponentialSearch = new ExponentialSearch();
+        for (int length = 1; length <= 50; length++) {
+            Integer[] array = new Integer[length];
+            for (int i = 0; i < length; i++) {
+                array[i] = i * 2;
+            }
+            for (int i = 0; i < length; i++) {
+                assertEquals(i, exponentialSearch.find(array, i * 2), "Element at index " + i + " should be found for length " + length + ".");
+            }
+        }
+    }
+
+    /**
+     * A missing key has to yield -1 rather than the negative insertion point that
+     * {@link java.util.Arrays#binarySearch} returns.
+     */
+    @Test
+    void testExponentialSearchNotFoundReturnsMinusOne() {
+        ExponentialSearch exponentialSearch = new ExponentialSearch();
+        Integer[] array = {1, 3, 5, 7, 9, 11};
+        assertEquals(-1, exponentialSearch.find(array, 4), "A key inside the range but absent should give -1.");
+        assertEquals(-1, exponentialSearch.find(array, 0), "A key below the minimum should give -1.");
+        assertEquals(-1, exponentialSearch.find(array, 12), "A key above the maximum should give -1.");
+    }
 }

src/test/java/com/thealgorithms/searches/JumpSearchTest.java

@@ -2,7 +2,9 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 /**
  * Unit tests for the JumpSearch class.
@@ -91,4 +93,50 @@ void testJumpSearchLargeArrayNotFound() {
         Integer key = 999; // Key not present
         assertEquals(-1, jumpSearch.find(array, key), "The element should not be found in the array.");
     }
+
+    /**
+     * A key greater than every element used to make the jumping loop spin forever, because the
+     * cursor was clamped to the last index and therefore stopped advancing.
+     */
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
+    void testJumpSearchKeyGreaterThanLastElement() {
+        JumpSearch jumpSearch = new JumpSearch();
+        Integer[] array = {1, 2, 3, 4};
+        assertEquals(-1, jumpSearch.find(array, 5), "A key above the maximum should not be found.");
+    }
+
+    /**
+     * The same regression across several lengths, since the jump size depends on the array length.
+     */
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
+    void testJumpSearchKeyGreaterThanLastElementForEveryLength() {
+        JumpSearch jumpSearch = new JumpSearch();
+        for (int length = 1; length <= 50; length++) {
+            Integer[] array = new Integer[length];
+            for (int i = 0; i < length; i++) {
+                array[i] = i;
+            }
+            assertEquals(-1, jumpSearch.find(array, length), "A key above the maximum should not be found for length " + length + ".");
+        }
+    }
+
+    /**
+     * Every element must be found regardless of the array length, including the ones that sit
+     * exactly on a jump boundary.
+     */
+    @Test
+    void testJumpSearchFindsEveryElement() {
+        JumpSearch jumpSearch = new JumpSearch();
+        for (int length = 1; length <= 50; length++) {
+            Integer[] array = new Integer[length];
+            for (int i = 0; i < length; i++) {
+                array[i] = i * 2;
+            }
+            for (int i = 0; i < length; i++) {
+                assertEquals(i, jumpSearch.find(array, i * 2), "Element at index " + i + " should be found for length " + length + ".");
+            }
+        }
+    }
 }