fix: correct Javadoc formatting and add missing newline at EOF

- Fix Javadoc structure with proper tag ordering (description before @params)
- Remove incorrect @throws tag (method returns -1, doesn't throw)
- Format algorithm steps as proper HTML ordered list
- Move complexity analysis before @param tags
- Add missing newline at end of file
- Fix example code to use instance method call

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ghorpadeire

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

@@ -41,20 +41,20 @@ class BinarySearch implements SearchAlgorithm {
      * Generic method to perform binary search on any comparable type. This is the main entry point
      * for binary search operations.
      *
-     * @param <T> The type of elements in the array (must be Comparable)
-     * @param array The sorted array to search in (MUST be sorted in ascending order)
-     * @param key The element to search for
-     * @return The index of the key if found, -1 if not found
-     * @throws NullPointerException if array is null
-     *     <p>Example Usage:
-     *     <pre>
+     * <p>Example Usage:
+     * <pre>
      * Integer[] numbers = {1, 3, 5, 7, 9, 11};
-     * int result = BinarySearch.find(numbers, 7);
+     * int result = new BinarySearch().find(numbers, 7);
      * // result will be 3 (index of element 7)
      *
-     * int notFound = BinarySearch.find(numbers, 4);
+     * int notFound = new BinarySearch().find(numbers, 4);
      * // notFound will be -1 (element 4 does not exist)
      * </pre>
+     *
+     * @param <T> The type of elements in the array (must be Comparable)
+     * @param array The sorted array to search in (MUST be sorted in ascending order)
+     * @param key The element to search for
+     * @return The index of the key if found, -1 if not found or if array is null/empty
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
@@ -71,18 +71,23 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
      * Core recursive implementation of binary search algorithm. This method divides the problem
      * into smaller subproblems recursively.
      *
-     * <p>How it works: 1. Calculate the middle index to avoid integer overflow 2. Check if middle
-     * element matches the target 3. If not, recursively search either left or right half 4. Base
-     * case: left &gt; right means element not found
+     * <p>How it works:
+     * <ol>
+     * <li>Calculate the middle index to avoid integer overflow</li>
+     * <li>Check if middle element matches the target</li>
+     * <li>If not, recursively search either left or right half</li>
+     * <li>Base case: left &gt; right means element not found</li>
+     * </ol>
+     *
+     * <p>Time Complexity: O(log n) because we halve the search space each time.
+     * Space Complexity: O(log n) due to recursive call stack.
      *
      * @param <T> The type of elements (must be Comparable)
      * @param array The sorted array to search in
      * @param key The element we're looking for
      * @param left The leftmost index of current search range (inclusive)
      * @param right The rightmost index of current search range (inclusive)
      * @return The index where key is located, or -1 if not found
-     *     <p>Time Complexity: O(log n) because we halve the search space each time Space
-     *     Complexity: O(log n) due to recursive call stack
      */
     private <T extends Comparable<T>> int search(T[] array, T key, int left, int right) {
         // Base case: Search space is exhausted
@@ -119,4 +124,4 @@ else if (comp < 0) {
             return search(array, key, median + 1, right);
         }
     }
-}
+}