Merge branch 'master' into clustring

Author: Ashish2343

.github/workflows/stale.yml

@@ -11,7 +11,7 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10.4.0
+      - uses: actions/stale@v11.0.0
         with:
           stale-issue-message: 'This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contribution!'
           close-issue-message: 'Please reopen this issue once you have made the required changes. If you need help, feel free to ask in our [Discord](https://the-algorithms.com/discord) server or ping one of the maintainers here. Thank you for your contribution!'

pom.xml

@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.8.0</version>
+                    <version>13.9.0</version>
                     </dependency>
                 </dependencies>
             </plugin>

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/FibonacciSearch.java

@@ -69,7 +69,7 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
             }
         }
 
-        if (fibMinus1 == 1 && array[offset + 1] == key) {
+        if (fibMinus1 == 1 && offset + 1 < n && array[offset + 1].compareTo(key) == 0) {
             return offset + 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/FibonacciSearchTest.java

@@ -121,4 +121,53 @@ void testFibonacciSearchLargeArray() {
         int expectedIndex = 9999;
         assertEquals(expectedIndex, fibonacciSearch.find(array, key), "The index of the last element should be 9999.");
     }
+
+    /**
+     * A key greater than every element used to throw {@link ArrayIndexOutOfBoundsException},
+     * because the final probe read {@code array[offset + 1]} without checking the bound.
+     */
+    @Test
+    void testFibonacciSearchKeyGreaterThanLastElement() {
+        FibonacciSearch fibonacciSearch = new FibonacciSearch();
+        for (int length = 1; length <= 50; length++) {
+            Integer[] array = new Integer[length];
+            for (int i = 0; i < length; i++) {
+                array[i] = i;
+            }
+            assertEquals(-1, fibonacciSearch.find(array, length), "A key above the maximum should not be found for length " + length + ".");
+        }
+    }
+
+    /**
+     * The final probe used reference equality, so a key that is equal but not identical to the
+     * stored element was reported as missing. Values above 127 are outside the {@link Integer}
+     * cache and therefore are not the same object as the boxed array element.
+     */
+    @Test
+    void testFibonacciSearchFindsEqualButNotIdenticalKey() {
+        FibonacciSearch fibonacciSearch = new FibonacciSearch();
+        Integer[] array = {10, 20, 300};
+        assertEquals(2, fibonacciSearch.find(array, Integer.valueOf(300)), "The index of the found element should be 2.");
+
+        String[] words = {"a", "b", "c"};
+        String equalButDistinct = new StringBuilder("c").toString();
+        assertEquals(2, fibonacciSearch.find(words, equalButDistinct), "The index of the found element should be 2.");
+    }
+
+    /**
+     * Every element must be found regardless of the array length.
+     */
+    @Test
+    void testFibonacciSearchFindsEveryElement() {
+        FibonacciSearch fibonacciSearch = new FibonacciSearch();
+        for (int length = 1; length <= 50; length++) {
+            Integer[] array = new Integer[length];
+            for (int i = 0; i < length; i++) {
+                array[i] = 1000 + i * 2;
+            }
+            for (int i = 0; i < length; i++) {
+                assertEquals(i, fibonacciSearch.find(array, Integer.valueOf(1000 + i * 2)), "Element at index " + i + " should be found for length " + length + ".");
+            }
+        }
+    }
 }

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 + ".");
+            }
+        }
+    }
 }