Fix

Author: Hardvan

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

@@ -2,58 +2,36 @@
 
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
 
-/**
- * FibonacciSearch is a search algorithm that finds the position of a target value in
- * a sorted array using Fibonacci numbers.
+/*
+ *  Fibonacci Search is a popular algorithm which finds the position of a target value in
+ *  a sorted array
  *
- * <p>
- * The time complexity for this search algorithm is O(log n).
- * The space complexity for this search algorithm is O(1).
- * </p>
- *
- * <p>
- * Note: This algorithm requires that the input array be sorted.
- * </p>
+ *  The time complexity for this search algorithm is O(log3(n))
+ *  The space complexity for this search algorithm is O(1)
+ *  @author Kanakalatha Vemuru (https://github.com/KanakalathaVemuru)
  */
 public class FibonacciSearch implements SearchAlgorithm {
 
     /**
-     * Finds the index of the specified key in a sorted array using Fibonacci search.
-     *
-     * @param array The sorted array to search.
-     * @param key The element to search for.
-     * @param <T> The type of the elements in the array, which must be comparable.
-     * @throws IllegalArgumentException if the input array is not sorted or empty, or if the key is null.
-     * @return The index of the key if found, otherwise -1.
+     * @param array is a sorted array where the element has to be searched
+     * @param key is an element whose position has to be found
+     * @param <T> is any comparable type
+     * @return index of the element
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
-        if (array.length == 0) {
-            throw new IllegalArgumentException("Input array must not be empty.");
-        }
-        if (!isSorted(array)) {
-            throw new IllegalArgumentException("Input array must be sorted.");
-        }
-        if (key == null) {
-            throw new IllegalArgumentException("Key must not be null.");
-        }
-
         int fibMinus1 = 1;
         int fibMinus2 = 0;
         int fibNumber = fibMinus1 + fibMinus2;
         int n = array.length;
-
         while (fibNumber < n) {
             fibMinus2 = fibMinus1;
             fibMinus1 = fibNumber;
             fibNumber = fibMinus2 + fibMinus1;
         }
-
         int offset = -1;
-
         while (fibNumber > 1) {
             int i = Math.min(offset + fibMinus2, n - 1);
-
             if (array[i].compareTo(key) < 0) {
                 fibNumber = fibMinus1;
                 fibMinus1 = fibMinus2;
@@ -67,20 +45,21 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
                 return i;
             }
         }
-
         if (fibMinus1 == 1 && array[offset + 1] == key) {
             return offset + 1;
         }
-
         return -1;
     }
 
-    private boolean isSorted(Comparable[] array) {
-        for (int i = 1; i < array.length; i++) {
-            if (array[i - 1].compareTo(array[i]) > 0) {
-                return false;
-            }
-        }
-        return true;
+    // Driver Program
+    public static void main(String[] args) {
+        Integer[] integers = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
+
+        int size = integers.length;
+        Integer targetValue = 128;
+        FibonacciSearch fsearch = new FibonacciSearch();
+        int atIndex = fsearch.find(integers, targetValue);
+
+        System.out.println("Should be found: " + targetValue + ". Found " + integers[atIndex] + " at index " + atIndex + ". An array length " + size);
     }
 }