Merge pull request #88 from LALITH0110/master

Add Binary Search Algorithm Implementation

Author: abhishektripathi66

.DS_Store

@@ -0,0 +1,40 @@
+public class BinarySearch {
+    
+    /**
+     * Performs a binary search on a sorted array.
+     * 
+     * @param arr The sorted array to search in
+     * @param target The value to search for
+     * @return The index of the target if found, -1 otherwise
+     */
+    public static int binarySearch(int[] arr, int target) {
+        int low = 0;
+        int high = arr.length - 1;             // Fixed: high should be arr.length - 1
+        
+        while (low <= high) {
+            int mid = low + (high - low) / 2;  // Prevents potential overflow
+        
+            if (arr[mid] == target) {
+                return mid;                    // Target found
+            } else if (arr[mid] < target) {
+                low = mid + 1;                 // Target is in the upper half
+            } else {
+                high = mid - 1;                // Target is in the lower half
+            }
+        }
+        return -1;                             // Target not found
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {2, 3, 4, 10, 40};             // Sample sorted array
+        int target = 10;                           // Value to search for
+        
+        int result = binarySearch(arr, target);
+        
+        if (result == -1) {
+            System.out.println("Element " + target + " is not present in the array");
+        } else {
+            System.out.println("Element " + target + " found at index " + result);
+        }
+    }
+}

src/.DS_Store

@@ -0,0 +1,78 @@
+# Binary Search Algorithm
+Binary search is a fast and efficient searching algorithm used to find a specific element in a sorted array. It operates on the principle of divide and conquer, repeatedly dividing the search interval in half.
+
+## How Binary Search Works
+* The algorithm begins by comparing the target value with the middle element of the sorted array.
+* If the target matches the middle element, the search is successful, and the index is returned.
+* If the target is less than the middle element, the search continues in the lower half of the array.
+* If the target is greater than the middle element, the search continues in the upper half of the array.
+* This process repeats, halving the search interval each time, until the target is found or the search interval is empty.
+
+## Time Complexity
+The time complexity of binary search is O(log n), where n is the number of elements in the array. This logarithmic time complexity makes binary search significantly faster than linear search for large datasets.
+
+## Prerequisites
+The array must be sorted in ascending or descending order.
+If the array is not sorted, binary search will not work correctly and may return incorrect results.
+
+## Implementation
+Here's a Python implementation of the binary search algorithm using both iterative and recursive approaches:
+
+## Iterative Implementation
+```Java
+public static int binarySearch(int[] arr, int target) {
+    int left = 0;
+    int right = arr.length - 1;
+    
+    while (left <= right) {
+        int mid = left + (right - left) / 2;
+        if (arr[mid] == target) {
+            return mid;
+        } else if (arr[mid] < target) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    
+    return -1;  // Target not found
+}
+```
+
+Recursive Implementation
+``` Java
+public static int binarySearchRecursive(int[] arr, int target, int left, int right) {
+    if (left > right) {
+        return -1;  // Target not found
+    }
+    
+    int mid = left + (right - left) / 2;
+    if (arr[mid] == target) {
+        return mid;
+    } else if (arr[mid] < target) {
+        return binarySearchRecursive(arr, target, mid + 1, right);
+    } else {
+        return binarySearchRecursive(arr, target, left, mid - 1);
+    }
+}
+```
+
+## Advantages of Binary Search
+* Efficiency: Binary search is much faster than linear search for large datasets.
+* Logarithmic time complexity: The search space is halved in each iteration, resulting in O(log n) time complexity.
+* Works well with large, sorted datasets: Particularly useful when dealing with extensive, ordered collections of data.
+
+## Limitations
+* Requires sorted data: The array must be sorted before applying binary search.
+* Not suitable for small datasets: For very small arrays, linear search might be faster due to less overhead.
+* Not applicable to unsorted data structures: Binary search cannot be directly applied to unsorted lists or arrays.
+  
+## Applications
+Binary search is widely used in various applications, including:
+* Searching in large databases
+* Finding elements in sorted arrays
+* Implementing efficient dictionary lookups
+* Optimizing other algorithms that work on sorted data
+  
+## Conclusion
+Binary search is a powerful algorithm that significantly reduces search time in sorted arrays. Its logarithmic time complexity makes it an essential tool for efficient searching in large datasets. However, it's important to remember that the prerequisite of a sorted array is crucial for the algorithm to function correctly.