Merge branch 'master' into feat/add-bell-numbers

Author: singhc7

src/main/java/com/thealgorithms/recursion/FibonacciSeries.java

@@ -1,16 +1,26 @@
 package com.thealgorithms.recursion;
 
-/*
-    The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones,
-    starting with 0 and 1.
-       NUMBER    0 1 2 3 4 5 6 7  8  9  10 ...
-       FIBONACCI 0 1 1 2 3 5 8 13 21 34 55 ...
-*/
+/**
+ * The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones,
+ * starting with 0 and 1.
+ * <p>
+ * Example:
+ * 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ...
+ * </p>
+ */
 
 public final class FibonacciSeries {
     private FibonacciSeries() {
         throw new UnsupportedOperationException("Utility class");
     }
+
+    /**
+     * Calculates the nth term in the Fibonacci sequence using recursion.
+     *
+     * @param n the position in the Fibonacci sequence (must be non-negative)
+     * @return the nth Fibonacci number
+     * @throws IllegalArgumentException if n is negative
+     */
     public static int fibonacci(int n) {
         if (n < 0) {
             throw new IllegalArgumentException("n must be a non-negative integer");

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

@@ -1,21 +1,26 @@
 package com.thealgorithms.searches;
 
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
-
 /**
- * Linear search is the easiest search algorithm It works with sorted and
- * unsorted arrays (an binary search works only with sorted array) This
- * algorithm just compares all elements of an array to find a value
+ * Linear Search is a simple searching algorithm that checks
+ * each element of the array sequentially until the target
+ * value is found or the array ends.
+ *
+ * It works for both sorted and unsorted arrays.
  *
- * <p>
- * Worst-case performance O(n) Best-case performance O(1) Average performance
- * O(n) Worst-case space complexity
+ * Time Complexity:
+ *  - Best case: O(1)
+ *  - Average case: O(n)
+ *  - Worst case: O(n)
  *
- * @author Varun Upadhyay (https://github.com/varunu28)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
+ * Space Complexity: O(1)
+ *
+ * @author Varun Upadhyay
+ * @author Podshivalov Nikita
  * @see BinarySearch
  * @see SearchAlgorithm
  */
+
 public class LinearSearch implements SearchAlgorithm {
 
     /**