Binary Search (Recursive and Iterative) – Python

Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). 

Below is the step-by-step algorithm for Binary Search:

• Divide the search space into two halves by finding the middle index “mid”. 
• Compare the middle element of the search space with the key. 
• If the key is found at middle element, the process is terminated.
• If the key is not found at middle element, choose which half will be used as the next search space.
  • If the key is smaller than the middle element, then the left side is used for next search.
  • If the key is larger than the middle element, then the right side is used for next search.
• This process is continued until the key is found or the total search space is exhausted.

How does Binary Search Algorithm work?

To understand the working of binary search, consider the following illustration:

Consider an array arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}, and the target = 23.

1 / 4

Code Implementation

1. Python Program for Binary Search Using Recursive

Create a recursive function and compare the mid of the search space with the key. And based on the result either return the index where the key is found or call the recursive function for the next search space.

# Python 3 program for recursive binary search.
# Modifications needed for the older Python 2 are found in comments.

# Returns index of x in arr if present, else -1
def binary_search(arr, low, high, x):

    # Check base case
    if high >= low:

        mid = (high + low) // 2

        # If 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
        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        # Else the element can only be present in right subarray
        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        # Element is not present in the array
        return -1

# Test array
arr = [ 2, 3, 4, 10, 40 ]
x = 10

# Function call
result = binary_search(arr, 0, len(arr)-1, x)

if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

Element is present at index 3

Time Complexity: O(log n)

Auxiliary Space: O(logn)     [NOTE: Recursion creates Call Stack]

2. Python Program for Binary Search Using Iterative 

Here we use a while loop to continue the process of comparing the key and splitting the search space in two halves.

# Iterative Binary Search Function
# It returns index of x in given array arr if present,
# else returns -1
def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = 0

    while low <= high:

        mid = (high + low) // 2

        # If x is greater, ignore left half
        if arr[mid] < x:
            low = mid + 1

        # If x is smaller, ignore right half
        elif arr[mid] > x:
            high = mid - 1

        # means x is present at mid
        else:
            return mid

    # If we reach here, then the element was not present
    return -1


# Test array
arr = [ 2, 3, 4, 10, 40 ]
x = 10

# Function call
result = binary_search(arr, x)

if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

Element is present at index 3

Time Complexity: O(log n)

Auxiliary Space: O(1)

3. Python Program for Binary Search Using the built-in bisect module

Step by step approach:

• The code imports the bisect module which provides support for binary searching.
• The binary_search_bisect() function is defined which takes an array arr and the element to search x as inputs.
• The function calls the bisect_left() function of the bisect module which finds the position of the element in the sorted array arr where x should be inserted to maintain the sorted order. If the element is already present in the array, this function will return its position.
• The function then checks if the returned index i is within the range of the array and if the element at that index is equal to x.
• If the condition is true, then the function returns the index i as the position of the element in the array.
• If the condition is false, then the function returns -1 indicating that the element is not present in the array.
• The code then defines an array arr and an element x to search.
• The binary_search_bisect() function is called with arr and x as inputs and the returned result is stored in the result variable.
• The code then checks if the result is not equal to -1, indicating that the element is present in the array. If true, it prints the position of the element in the array.
• If the result is equal to -1, then the code prints a message that the element is not present in the array.

import bisect
 
def binary_search_bisect(arr, x):
    i = bisect.bisect_left(arr, x)
    if i != len(arr) and arr[i] == x:
        return i
    else:
        return -1
 
 
# Test array
arr = [2, 3, 4, 10, 40]
x = 10
 
# Function call
result = binary_search_bisect(arr, x)
 
if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

Element is present at index 3

Time Complexity: O(log n)

Auxiliary Space: O(1)

Python Program for Binary Search (Recursive and Iterative) – FAQs

What is Binary Search?

Binary Search is an efficient algorithm for finding an item from a sorted list or array. It works by repeatedly dividing the search interval in half:

• If the value of the search key is less than the item in the middle of the interval, the search continues in the lower half.
• If the value is greater, the search continues in the upper half.
• The process is repeated until the value is found or the interval is empty.

Can Binary Search be applied to unsorted lists?

No, binary search requires the list to be sorted. If the list is not sorted, the algorithm will not work correctly.

How do you handle duplicate elements in Binary Search?

Binary search does not handle duplicates explicitly. If duplicates are present, it will find one of the occurrences of the element, but it won’t guarantee which one. To find the first or last occurrence of a duplicate, you need to modify the binary search algorithm.

Can Binary Search be used on other data structures?

Yes, binary search can be used on other sorted data structures such as binary search trees (BST) and sorted arrays. The principle of halving the search space is applicable to various types of sorted data structures.

kartik

Follow

Improve

Article Tags :

• Python Programs
• python searching-exercises