## Introduction

In this article, we will understand the binary search algorithm. The binary search algorithm is a highly efficient method for finding a specific element in a sorted array. It works by repeatedly dividing the search interval in half, significantly reducing the number of comparisons needed to locate the desired element. This algorithm has a time complexity of O(log n), making it much faster than linear search for large datasets.

### Working on Binary Search

- Start with a sorted array.
- Define the search range (initially the entire array).
- Find the middle element of the current range.
- If the middle element is the target, return its index.
- If the target is less than the middle element, search the left half.
- If the target is greater than the middle element, search the right half.
- Repeat steps 3-6 until the element is found or the range is empty.

### Advantages of Binary Search

**Efficiency:**Binary search is much faster than linear search for large datasets.**Simplicity:**The algorithm is relatively easy to understand and implement.**Space complexity:**It uses minimal extra space (O(1) for iterative implementation).

### Flow Diagram of Binary Searching Algorithm

Let's implement the binary search algorithm in Java.

```
public class BinarySearchExample {
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; // Target found
}
if (arr[mid] < target) {
left = mid + 1; // Target is in the right half
} else {
right = mid - 1; // Target is in the left half
}
}
return -1; // Target not found
}
public static void main(String[] args) {
int[] arr = {2, 3, 4, 10, 40};
int target = 10;
int result = binarySearch(arr, target);
if (result == -1) {
System.out.println("Element not present in array");
} else {
System.out.println("Element found at index " + result);
}
}
}
```

**In the above code Example**

- We define the binarySearch method that takes a sorted array and a target value as input.
- We initialize two pointers, left and right, to the start and end of the array.
- We enter a while loop that continues as long as the left is less than or equal to the right.
- In each iteration, we calculate the middle index using mid = left + (right-left) / 2. This formula avoids potential integer overflow that could occur with (left + right) / 2.
- We compare the middle element with the target:
- If they are equal, we have found the target and returned its index.
- If the target is greater, we update the left to search the right half.
- If the target is smaller, we update the right to search the left half.

- If the loop ends without finding the target, we return -1 to indicate the element is not in the array.

### Complexity

The time complexity of binary search is O(log n), where n is the number of elements in the array. This is because the algorithm divides the search space in half with each iteration. Even for very large arrays, binary search can find the target (or determine its absence) in a relatively small number of steps.

## Summary

The binary search algorithm is a powerful tool for efficiently searching sorted arrays. Its logarithmic time complexity makes it an excellent choice for large datasets. While it requires the input array to be sorted (which can be a preprocessing overhead), the sorting cost is often outweighed by the speed gains in subsequent searches, especially when multiple searches are performed on the same dataset.