We are given a sorted array of size n. We have to write program to find an element x in arr[].

In the previous post we have implemented linear search. Now we are going to implement another approach to search it. This approach is called Binary Search.

**Binary Search** – Search an element in sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, narrow the interval to the lower half. Otherwise, narrow it to the upper half. Repeatedly check until the value is found or the interval is empty.

Binary Search is more time efficient as its time complexity is O (log n )compared to linear search(time complexity O( n)).

- Compare the search element with the middle element.
- if it matches with the element then return the middle index.
- else if element is greater than middle element then it lies only on right half subarray so we recur right half otherwise it lies on left half subarray then we recur left half.

##### Recursive Implementation

```
// C program to implement recursive Binary Search
#include <stdio.h>
// A recursive binary search function. It returns
// location of x in given array arr[l..r] is present,
// otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l) {
int mid = l + (r - l) / 2;
// If the element is present at the middle
// itself
if (arr[mid] == x)
return mid;
// If element is smaller than mid, then
// it can only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
// Else the element can only be present
// in right subarray
return binarySearch(arr, mid + 1, r, x);
}
// We reach here when element is not
// present in array
return -1;
}
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
int result = binarySearch(arr, 0, n - 1, x);
(result == -1) ? printf("Element is not present in array")
: printf("Element is present at index %d",
result);
return 0;
}
```

**Output :**

Element is present at index 3

##### Iterative Implementation

```
// C program to implement iterative Binary Search
#include <stdio.h>
// A iterative binary search function. It returns
// location of x in given array arr[l..r] if present,
// otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
while (l <= r) {
int m = l + (r - l) / 2;
// Check if x is present at mid
if (arr[m] == x)
return m;
// If x greater, ignore left half
if (arr[m] < x)
l = m + 1;
// If x is smaller, ignore right half
else
r = m - 1;
}
// if we reach here, then element was
// not present
return -1;
}
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
int result = binarySearch(arr, 0, n - 1, x);
(result == -1) ? printf("Element is not present"
" in array")
: printf("Element is present at "
"index %d",
result);
return 0;
}
```

**Output :**

Element is present at index 3

**Time Complexity:**

The time complexity of Binary Search can be written as

T(n) = T(n/2) + c

The above recurrence can be solved either using the Recurrence Tree method or Master method. It falls in case II of the Master Method and the solution of the recurrence is .**Auxiliary Space:** O(1) in case of iterative implementation. In the case of recursive implementation, O(Logn) recursion call stack space.

**Algorithmic Paradigm:** Decrease and Conquer

**Note:**

Here we are using

int mid = low + (high – low)/2;

Maybe, you wonder why we are calculating the **middle index**** **this way, we can simply add the *lower and higher index and divide it by 2.*

int mid = (low + high)/2;

But if we calculate the** *** middle index *like this means our code is not 100% correct, it contains bugs.

That is, it fails for larger values of int variables low and high. Specifically, it fails if the sum of low and high is greater than the maximum positive int value(2^{31} – 1^{ }).

The sum overflows to a negative value and the value stays negative when divided by 2. In java, it throws *ArrayIndexOutOfBoundException.*

int mid = low + (high – low)/2;

So it’s better to use it like this. This bug applies equally to merge sort and other divide and conquer algorithms.

#### Important Notice

If you’re a college student and have skills in programming languages, Want to earn through blogging? Mail us at geekycomail@gmail.com

For more Programming related blogs Visit Us Geekycodes . Follow us on Instagram.