Binary Search — Divide & Conquer Search

Why read this? Imagine searching for a friend's name in a phone book by starting at page 1 and reading every single name. That's linear search — simple but painfully slow. Binary search is the "open to the middle" strategy: each comparison eliminates half the remaining data. Searching a sorted list of 1 million items takes just 20 comparisons instead of up to 1 million. This exponential speedup is one of the most important ideas in computer science.

🎯 Learning Objectives

1. Explain how binary search works (divide and conquer)
2. Implement binary search iteratively (while loop)
3. Implement binary search recursively
4. Calculate time complexity: O(log n)
5. Understand the requirement that data must be sorted
6. Apply binary search to real-world problems

📋 Prerequisites

• Recursion — For the recursive implementation.
• Lists — Searching through sorted lists.
• While Loops — For the iterative implementation.

📖 Core Content

24.1 What Problem Does Binary Search Solve?

24.2 The Algorithm — Step by Step

pseudo
Iteration 1: low=0, high=9, mid=(0+9)//2=4, list[4]=16
  16 < 23, so search right: low=5
Iteration 2: low=5, high=9, mid=(5+9)//2=7, list[7]=45
  45 > 23, so search left: high=6
Iteration 3: low=5, high=6, mid=(5+6)//2=5, list[5]=23
  23 == 23 → FOUND at index 5! Return 5.

24.3 Iterative Binary Search

python
Run Inline
# runnable
def binary_search_iterative(lst, target):
    """
    Search for target in sorted list.
    Returns index if found, -1 if not found.
    """
    low = 0
    high = len(lst) - 1
    while low <= high:
        mid = (low + high) // 2  # integer division
        mid_val = lst[mid]
        if mid_val == target:
            return mid          # Found!
        elif mid_val < target:
            low = mid + 1       # Search right half
        else:
            high = mid - 1      # Search left half
    return -1  # Not found
# Test
data = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72]
tests = [23, 1, 72, 100]
for t in tests:
    result = binary_search_iterative(data, t)
    if result != -1:
        print(f"{t} found at index {result}")
    else:
        print(f"{t} not found")

pseudo
23 found at index 5
1 not found
72 found at index 9
100 not found

24.4 Recursive Binary Search

python
Run Inline
# runnable
def binary_search_recursive(lst, target, low, high):
    """
    Recursive binary search.
    Base case: low > high (empty range) → not found.
    """
    # Base case: empty search range
    if low > high:
        return -1
    mid = (low + high) // 2
    if lst[mid] == target:
        return mid
    elif lst[mid] < target:
        # Search right half
        return binary_search_recursive(lst, target, mid + 1, high)
    else:
        # Search left half
        return binary_search_recursive(lst, target, low, mid - 1)
# Wrapper function (easier to call)
def binary_search(lst, target):
    return binary_search_recursive(lst, target, 0, len(lst) - 1)
# Test
data = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72]
print(binary_search(data, 23))   # 5
print(binary_search(data, 1))    # -1
print(binary_search(data, 72))   # 9

pseudo
5
-1
9

24.5 Time Complexity Analysis

• n = 10 → log₂(10) ≈ 4 steps max
• n = 1,000 → log₂(1000) ≈ 10 steps max
• n = 1,000,000 → log₂(1,000,000) ≈ 20 steps max
• n = 1,000,000,000 → log₂(1B) ≈ 30 steps max

python
Run Inline
# runnable
import math
sizes = [10, 100, 1000, 10000, 100000, 1000000, 1000000000]
print("n             | log2(n) | Linear worst")
print("-" * 45)
for n in sizes:
    log_n = int(math.ceil(math.log2(n)))
    print(f"{n:12,} | {log_n:7} | {n:13,}")

pseudo
n             | log2(n) | Linear worst
---------------------------------------------
          10 |       4 |            10
         100 |       7 |           100
       1,000 |      10 |         1,000
      10,000 |      14 |        10,000
     100,000 |      17 |       100,000
   1,000,000 |      20 |     1,000,000
1,000,000,000 |      30 | 1,000,000,000

24.6 Worked Example 1: First Occurrence (with Duplicates)

python
Run Inline
# runnable
def binary_search_first(lst, target):
    """Find FIRST occurrence of target (handles duplicates)."""
    low, high = 0, len(lst) - 1
    result = -1
    while low <= high:
        mid = (low + high) // 2
        if lst[mid] == target:
            result = mid        # Record this position
            high = mid - 1      # Keep searching LEFT for earlier occurrence
        elif lst[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return result
# Test with duplicates
data = [1, 2, 3, 3, 3, 4, 5, 5, 6, 7]
print(f"First 3 at index: {binary_search_first(data, 3)}")  # 2
print(f"First 5 at index: {binary_search_first(data, 5)}")  # 6

pseudo
First 3 at index: 2
First 5 at index: 6

24.7 Worked Example 2: Square Root Approximation

python
Run Inline
# runnable
def sqrt_binary_search(n, precision=0.0001):
    """Compute square root using binary search."""
    if n < 0:
        return None
    if n == 0 or n == 1:
        return n
    low, high = 0, n
    # For numbers less than 1, high should be 1
    if n < 1:
        high = 1
    while high - low > precision:
        mid = (low + high) / 2
        mid_sq = mid * mid
        if mid_sq == n:
            return mid
        elif mid_sq < n:
            low = mid
        else:
            high = mid
    return (low + high) / 2
# Test
for n in [4, 9, 16, 2, 100, 0.25]:
    result = sqrt_binary_search(n)
    print(f"√{n} ≈ {result:.4f}")

pseudo
√4 ≈ 2.0000
√9 ≈ 3.0000
√16 ≈ 4.0000
√2 ≈ 1.4142
√100 ≈ 10.0000
√0.25 ≈ 0.5000

24.8 Worked Example 3: Dictionary Word Lookup

python
Run Inline
# runnable
# Simulated dictionary
dictionary = [
    "apple", "banana", "cherry", "date", "elderberry",
    "fig", "grape", "honeydew", "kiwi", "lemon",
    "mango", "nectarine", "orange", "papaya", "quince"
]
def lookup_word(words, target):
    """Check if target word exists in dictionary."""
    index = binary_search_iterative(words, target)
    if index != -1:
        return f"'{target}' found at position {index + 1}"
    else:
        return f"'{target}' not found"
print(lookup_word(dictionary, "kiwi"))
print(lookup_word(dictionary, "grape"))
print(lookup_word(dictionary, "watermelon"))

pseudo
'kiwi' found at position 9
'grape' found at position 7
'watermelon' not found

24.9 Worked Example 4: Find Insert Position

python
Run Inline
# runnable
def find_insert_position(lst, target):
    """Return the index where target should be inserted."""
    low, high = 0, len(lst)
    while low < high:
        mid = (low + high) // 2
        if lst[mid] < target:
            low = mid + 1
        else:
            high = mid
    return low
data = [1, 3, 5, 7, 9, 11]
for val in [0, 4, 6, 12]:
    pos = find_insert_position(data, val)
    print(f"Insert {val:2} at index {pos}: {data[:pos] + [val] + data[pos:]}")

pseudo
Insert  0 at index 0: [0, 1, 3, 5, 7, 9, 11]
Insert  4 at index 2: [1, 3, 4, 5, 7, 9, 11]
Insert  6 at index 3: [1, 3, 5, 6, 7, 9, 11]
Insert 12 at index 6: [1, 3, 5, 7, 9, 11, 12]

24.10 Worked Example 5: Peak Element in Mountain Array

python
Run Inline
# runnable
def find_peak(arr):
    """Find peak element in a mountain array."""
    low, high = 0, len(arr) - 1
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < arr[mid + 1]:
            low = mid + 1  # Ascending, peak is to the right
        else:
            high = mid      # Descending, peak is at mid or left
    return low  # Peak index
mountain = [1, 3, 5, 7, 9, 8, 6, 4, 2]
peak = find_peak(mountain)
print(f"Mountain: {mountain}")
print(f"Peak at index {peak}: value = {mountain[peak]}")

pseudo
Mountain: [1, 3, 5, 7, 9, 8, 6, 4, 2]
Peak at index 4: value = 9

📐 Key Concepts Reference

⚠️ Common Pitfalls

Pitfall 1: Data Not Sorted

Pitfall 2: Off-by-One Errors in Range

Pitfall 3: Integer Overflow in Mid Calculation

Pitfall 4: Infinite Loop in Recursive Version

Pitfall 5: Forgetting the Wrapper Function for Recursive Version

📝 Practice Questions

Q1: How many steps does binary search take for a sorted list of 1024 elements in the worst case?

Answer: log₂(1024) = 10 steps maximum. After 10 halvings, the search range is reduced to 1 element. Q2: Why must the list be sorted for binary search to work?

Answer: Binary search decides which half to search next by comparing the target to the middle element. If the list is not sorted, this comparison doesn't guarantee which half contains the target — the target could be in either half regardless of the comparison result. Q3: Trace binary search for target=7 in [1, 3, 5, 7, 9, 11].

Answer:

pseudo
low=0, high=5, mid=2, list[2]=5 < 7 → search right: low=3
low=3, high=5, mid=4, list[4]=9 > 7 → search left: high=3
low=3, high=3, mid=3, list[3]=7 == 7 → FOUND at index 3

Q4: Write a function that uses binary search to find a target in a list of strings (case-insensitive).

Answer:

python
Run Inline
# runnable
def binary_search_case_insensitive(lst, target):
    """Binary search ignoring case. List must be sorted case-insensitively."""
    target_lower = target.lower()
    low, high = 0, len(lst) - 1

    while low <= high:
        mid = (low + high) // 2
        mid_lower = lst[mid].lower()

        if mid_lower == target_lower:
            return mid
        elif mid_lower < target_lower:
            low = mid + 1
        else:
            high = mid - 1
    return -1

# Test
words = sorted(["Apple", "Banana", "Cherry", "Date"], key=str.lower)
print(binary_search_case_insensitive(words, "banana"))  # 1
print(binary_search_case_insensitive(words, "BANANA"))  # 1
print(binary_search_case_insensitive(words, "grape"))   # -1

Q5: What's the worst-case time complexity of binary search compared to linear search?

Answer:

• Binary search: O(log n) — logarithmic
• Linear search: O(n) — linear For n=1,000,000: binary search takes ~20 comparisons, linear search takes up to 1,000,000. Q6: Write binary search that finds the LAST occurrence of a target (handling duplicates).

Answer:

python
Run Inline
# runnable
def binary_search_last(lst, target):
    low, high = 0, len(lst) - 1
    result = -1
    while low <= high:
        mid = (low + high) // 2
        if lst[mid] == target:
            result = mid
            low = mid + 1  # Search right for later occurrence
        elif lst[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return result

data = [1, 2, 3, 3, 3, 4, 5]
print(binary_search_last(data, 3))  # 4

Q7: What happens if you run binary search on [3, 1, 4, 1, 5, 9] (unsorted) looking for 9?

Answer: It might fail to find 9. The unsorted array means the assumption "if mid < target, target is in the right half" is invalid. The search might discard the half containing 9 and return -1 (not found) even though 9 is present. Q8: Write a program that uses binary search to check if a word is in a dictionary file.

Answer:

python
Run Inline
# runnable
# Simulate reading a dictionary file
dictionary_text = """apple
banana
cherry
date
elderberry
fig
grape
honeydew"""

words = dictionary_text.strip().split("\n")
words.sort()  # ensure sorted

def dictionary_lookup(word):
    idx = binary_search_iterative(words, word.lower())
    return idx != -1

# Test
print(dictionary_lookup("Cherry"))  # True
print(dictionary_lookup("kiwi"))    # False

Q9: Why does the recursive binary search have O(log n) space complexity?

Answer: Each recursive call adds a stack frame. In the worst case, the recursion depth is log₂(n) (the number of times we halve the array before reaching the base case). So we use O(log n) additional memory for the call stack. The iterative version only uses O(1) space. Q10: Implement a function that finds the smallest element in a rotated sorted array (e.g., [4,5,6,7,0,1,2] → 0) using a binary-search-like approach.

Answer:

python
Run Inline
# runnable
def find_min_rotated(arr):
    """Find minimum in rotated sorted array using binary search."""
    low, high = 0, len(arr) - 1

    while low < high:
        mid = (low + high) // 2

        if arr[mid] > arr[high]:
            low = mid + 1  # Min is in right half
        else:
            high = mid      # Min is at mid or left

    return arr[low]

rotated = [4, 5, 6, 7, 0, 1, 2]
print(f"Minimum in {rotated}: {find_min_rotated(rotated)}")  # 0

rotated2 = [3, 4, 5, 1, 2]
print(f"Minimum in {rotated2}: {find_min_rotated(rotated2)}")  # 1

🔗 Cross-References

• Next Topic: File Operations — Reading data from files to search through.
• Previous Topic: Recursion — Recursive binary search uses the same principles.
• BSCS1001 Computational Thinking: Binary search is the classic "divide and conquer" algorithm.
• BSCS2002 PDSA: Binary search is essential for efficient searching in data structures. Later courses explore binary search trees and balanced trees.
• Reference: Python for Everybody, Chapter 9 (Section 9.5) — "Searching" mentions linear search; binary search is covered in more depth in PDSA.
• Video: L81: Binary search implementation, L83: Binary search recursion way, L85: Warm up for binary search, L86: Introduction to binary search Join Discord Previous23. RecursionNext25. File Operations