Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python-program-for-binary-search/ below:

Binary Search (Recursive and Iterative) - Python

Last Updated : 21 Feb, 2025

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.

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.

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]

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)

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)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4