Binary search is an algorithm that searches for a target value in a sorted array by repeatedly dividing the search interval in half. It begins with an interval covering the whole array and if the target value is less than the middle element, it narrows the interval to the lower half, otherwise it narrows to the upper half. It repeats this process until the target is found or the interval is empty. The time complexity is O(log n), with the best case when the target is at the middle index and worst case when the target does not exist in the array. Examples in C++, Java, and Python are provided.

1. Algorithms
Binary Search
Abdelrahman M. Saleh

2. List of contents
● Introduction
● Example w/ illustrating figures
● Algorithm
● implementation (Java, C++, Python)
● Performance Runtime
○ Best, Average and worst cases.
● Execution
● Other Notes

3. Introduction
● Binary search works by dividing the array into halfes searching in one with the element
considering the complete array as the first half
● Unlike linear search binary search doesn’t search the whole array .

4. Example w/ illustrating figures

5. Algorithm .
● Search a 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.

6. Implementation .

7. C++
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l)
{
int mid = l + (r - l)/2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid-1, x);
return binarySearch(arr, mid+1, r, x);
}
return -1;
}

8. JAVA
static int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l)
{
int mid = l + (r - l)/2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid-1, x);
return binarySearch(arr, mid+1, r, x);
}
return -1;
}

9. Python .
def binarySearch (arr, l, r, x):
if r >= l:
mid = l + (r - l)/2
if arr[mid] == x:
return mid
elif arr[mid] > x:
return binarySearch(arr, l, mid-1, x)
else:
return binarySearch(arr, mid+1, r, x)
else:
return -1

10. Performance Runtime
● Time complexity F(n) = F(n/2) + c => Θ(log(n)) .
● Best case : when the element is at midium index .
● Worst case : if the element doesn’t exist .

11. Execution .
Input array : [1, 2, 3, 4, 6, 7, 9]
Find 2 :
mid index 3 => 2 != 4
Divide array :
Left part [1,2,3] , Right part [6,7,9]
2 > 1 && 2 < 3 => activate left part
mid index 1 => 2 == 2 //found
Element found on index 1

12. Other Notes .
● Algorithmic Paradigm: Divide and conquer Approach
● Stable: Yes
● Online: Yes
● Bubble search is one of the most of the preferred search algorithms due to it’s simplicity
in code and fast approach to find element .