Fix structure and package for Jump Search algorithm

Author: Fahham29

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

@@ -1,56 +1,40 @@
 package com.thealgorithms.searches;
 
-import com.thealgorithms.devutils.searches.SearchAlgorithm;
-
 /**
- * An implementation of the Jump Search algorithm.
- *
- * <p>
- * 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.
+ * Implementation of Jump Search algorithm.
  *
- * <p>
- * 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.
+ * Time Complexity: O(√n)
+ * Space Complexity: O(1)
  *
- * <p>
- * Worst-case performance: O(√N)<br>
- * Best-case performance: O(1)<br>
- * Average performance: O(√N)<br>
- * Worst-case space complexity: O(1)
- *
- * <p>
- * This class implements the {@link SearchAlgorithm} interface, providing a generic search method
- * for any comparable type.
+ * Reference: https://en.wikipedia.org/wiki/Jump_search
  */
-public class JumpSearch implements SearchAlgorithm {
 
-    /**
-     * Jump Search algorithm implementation.
-     *
-     * @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 <T extends Comparable<T>> int find(T[] array, T key) {
-        int length = array.length;
-        int blockSize = (int) Math.sqrt(length);
+public class JumpSearch {
+
+    public static int jumpSearch(int[] arr, int target) {
+        int n = arr.length;
+        int step = (int) Math.floor(Math.sqrt(n));
+        int prev = 0;
 
-        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);
+        while (arr[Math.min(step, n) - 1] < target) {
+            prev = step;
+            step += Math.floor(Math.sqrt(n));
+            if (prev >= n)
+                return -1;
         }
 
-        // Perform linear search within the identified block
-        for (int i = limit - blockSize; i <= limit && i < length; i++) {
-            if (array[i].equals(key)) {
+        for (int i = prev; i < Math.min(step, n); i++) {
+            if (arr[i] == target)
                 return i;
-            }
         }
+
         return -1;
     }
+
+    public static void main(String[] args) {
+        int[] arr = { 1, 3, 5, 7, 9, 12, 17, 21, 25 };
+        int target = 12;
+        int index = jumpSearch(arr, target);
+        System.out.println("Found at index: " + index);
+    }
 }