Added [FEATURE REQUEST] <Recursive Binary Search> #4457

src/main/java/com/thealgorithms/others/ReverseArray.java

@@ -0,0 +1,45 @@
+// Created by Pronay Debnath
+// Date:- 1/10/2023
+// Updated the existing code with documentations and some comments
+
+import java.util.*;
+
+public class ReverseArray {
+    /**
+     * Reverses the elements of an array in-place.
+     *
+     * @param a   The array to be reversed.
+     * @param start The starting index for the reversal.
+     * @param end   The ending index for the reversal.
+     */
+    public static void revarr(int[] a, int start, int end) {
+        int temp;
+        while (start < end) {
+            temp = a[start];
+            a[start] = a[end];
+            a[end] = temp;
+            start++;
+            end--;
+        }
+        System.out.println("Reversed array:");
+        for (int i = 0; i < a.length; i++) {
+            System.out.print(a[i]);
+            System.out.println();
+        }
+    }
+
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        // Adding user input functionality
+        System.out.print("Enter the array size: ");
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        System.out.println("Enter array elements: ");
+        for (int i = 0; i < n; i++) {
+            arr[i] = sc.nextInt();
+        }
+        int start = 0;
+        int end = n - 1;
+        revarr(arr, start, end);
+    }
+}

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

@@ -0,0 +1,61 @@
+// Code by Pronay Debnath
+// Created:- 1/10/2023
+// File Name should be RecursiveBinarySearch.java
+// Explanation:- https://www.tutorialspoint.com/java-program-for-binary-search-recursive
+
+import java.util.*;
+
+public class RecursiveBinarySearch<T extends Comparable<T>> {
+
+    // Recursive binary search function
+    public int binsear(T[] arr, int left, int right, T target) {
+        if (right >= left) {
+            int mid = left + (right - left) / 2;
+
+            // Compare the element at the middle with the target
+            int comparison = arr[mid].compareTo(target);
+
+            // If the element is equal to the target, return its index
+            if (comparison == 0) {
+                return mid;
+            }
+
+            // If the element is greater than the target, search in the left subarray
+            if (comparison > 0) {
+                return binsear(arr, left, mid - 1, target);
+            }
+
+            // Otherwise, search in the right subarray
+            return binsear(arr, mid + 1, right, target);
+        }
+
+        // Element is not present in the array
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        // User inputs
+        System.out.print("Enter the number of elements in the array: ");
+        int n = sc.nextInt();
+
+        Integer[] a = new Integer[n]; // You can change the array type as needed
+
+        System.out.println("Enter the elements in sorted order:");
+
+        for (int i = 0; i < n; i++) {
+            a[i] = sc.nextInt();
+        }
+
+        System.out.print("Enter the target element to search for: ");
+        int t = sc.nextInt();
+
+        RecursiveBinarySearch<Integer> searcher = new RecursiveBinarySearch<>();
+        int res = searcher.binsear(a, 0, n - 1, t);
+
+        if (res == -1)
+            System.out.println("Element not found in the array.");
+        else
+            System.out.println("Element found at index " + res);
+    }
+}

src/test/java/com/thealgorithms/searches/RecursiveBinarySearchTest.java

@@ -0,0 +1,40 @@
+// Created by Pronay Debnath
+// Date:- 1/10/2023
+// Test file updated with JUnit tests
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class RecursiveBinarySearchTest {
+
+    @Test
+    public void testBinarySearch() {
+        // Create an instance of GenericBinarySearch
+        GenericBinarySearch<Integer> searcher = new GenericBinarySearch<>();
+
+        // Test case 1: Element found in the array
+        Integer[] arr1 = {1, 2, 3, 4, 5};
+        int target1 = 3;
+        int result1 = searcher.binarySearch(arr1, 0, arr1.length - 1, target1);
+        assertEquals(2, result1);
+
+        // Test case 2: Element not found in the array
+        Integer[] arr2 = {1, 2, 3, 4, 5};
+        int target2 = 6;
+        int result2 = searcher.binarySearch(arr2, 0, arr2.length - 1, target2);
+        assertEquals(-1, result2);
+
+        // Test case 3: Element found at the beginning of the array
+        Integer[] arr3 = {10, 20, 30, 40, 50};
+        int target3 = 10;
+        int result3 = searcher.binarySearch(arr3, 0, arr3.length - 1, target3);
+        assertEquals(0, result3);
+
+        // Test case 4: Element found at the end of the array
+        Integer[] arr4 = {10, 20, 30, 40, 50};
+        int target4 = 50;
+        int result4 = searcher.binarySearch(arr4, 0, arr4.length - 1, target4);
+        assertEquals(4, result4);
+    }
+}