Why Binary Search Recursive Approach in DSA Python?

The Big Idea

What if you could find anything in a huge list in just a few quick steps?

The Scenario

Imagine you have a huge phone book with thousands of names sorted alphabetically. You want to find a friend's phone number. If you look at each name one by one from the start, it will take a very long time.

The Problem

Searching one by one is slow and tiring. You might lose your place or make mistakes. It wastes a lot of time, especially when the list is very long.

The Solution

Binary search splits the list in half each time. It quickly ignores the half where the name cannot be. Using recursion, the search repeats this splitting automatically until it finds the name or knows it is not there.

Before vs After

✗ Before

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

✓ After

def binary_search(arr, target, low, high):
    if low > high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search(arr, target, mid + 1, high)
    else:
        return binary_search(arr, target, low, mid - 1)

What It Enables

This approach makes searching in sorted lists super fast and efficient, even if the list is huge.

Real Life Example

When you search for a word in a dictionary app, it uses binary search to quickly find the word instead of checking every word one by one.

Key Takeaways

Manual searching is slow and error-prone.

Binary search cuts the search area in half each step.

Recursion helps repeat the process cleanly and simply.

Practice

1. What is the main idea behind the binary search recursive approach?

easy

A. Search every element one by one from start to end

B. Sort the list first and then search linearly

C. Divide the list into halves and search recursively in the half where the target may exist

D. Use a queue to store elements and search iteratively

Solution

1. Step 1: Understand binary search logic

   Binary search works by dividing the list into two halves and deciding which half to search next based on comparison with the middle element.

2. Step 2: Recognize recursive approach

   The recursive approach calls the same function on the half where the target could be, reducing the search space each time.

3. Final Answer:

   Divide the list into halves and search recursively in the half where the target may exist -> Option C

4. Quick Check:

   Binary search = divide and conquer [OK]

Hint: Think divide and conquer, search half recursively [OK]

Common Mistakes:

• Searching all elements linearly instead of dividing
• Not reducing the search space correctly
• Confusing iterative with recursive approach

2. Which of the following is the correct base case for a recursive binary search function in Python?

easy

A. if low > high: return -1

B. if low == high: return mid

C. if mid == target: return low

D. if high < low: return mid

Solution

1. Step 1: Identify base case condition

   The base case occurs when the search space is empty, meaning low index is greater than high index.

2. Step 2: Confirm correct return value

   When low > high, the target is not found, so return -1 to indicate failure.

3. Final Answer:

   if low > high: return -1 -> Option A

4. Quick Check:

   Empty search space means return -1 [OK]

Hint: Base case: low index passes high index means not found [OK]

Common Mistakes:

• Returning mid when low == high without checking target
• Using wrong comparison operators in base case
• Returning wrong index or value in base case

3. What will be the output of the following code?

def binary_search(arr, low, high, target):
    if low > high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] > target:
        return binary_search(arr, low, mid - 1, target)
    else:
        return binary_search(arr, mid + 1, high, target)

arr = [2, 4, 6, 8, 10]
print(binary_search(arr, 0, len(arr) - 1, 6))

medium

A. 1

B. 2

C. -1

D. 3

Solution

1. Step 1: Trace initial call

   Call binary_search(arr, 0, 4, 6). mid = (0+4)//2 = 2. arr[2] = 6 matches target 6.

2. Step 2: Return mid index

   Since arr[mid] == target, function returns 2 immediately.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Target 6 found at index 2 [OK]

Hint: Check middle element first, return index if match [OK]

Common Mistakes:

• Calculating mid incorrectly
• Returning wrong index
• Confusing target value with index

4. Find the error in the following recursive binary search code:

def binary_search(arr, low, high, target):
    if low >= high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] > target:
        return binary_search(arr, low, mid - 1, target)
    else:
        return binary_search(arr, mid + 1, high, target)

medium

A. Recursive calls should swap low and high parameters

B. Mid calculation should be 'mid = (low + high + 1) // 2'

C. Return value should be 'None' instead of '-1'

D. Base case condition should be 'if low > high' instead of 'if low >= high'

Solution

1. Step 1: Analyze base case condition

   The base case incorrectly uses 'if low >= high', which misses the case when low == high and target is at that index.

2. Step 2: Correct base case to 'if low > high'

   Changing to 'if low > high' allows checking the last element when low == high before returning -1.

3. Final Answer:

   Base case condition should be 'if low > high' instead of 'if low >= high' -> Option D

4. Quick Check:

   Base case must allow checking last element [OK]

Hint: Base case: low > high means search ended [OK]

Common Mistakes:

• Using >= instead of > in base case
• Incorrect mid calculation
• Returning wrong value on failure

5. Given a sorted list arr = [1, 3, 5, 7, 9, 11, 13], write a recursive binary search function to find the index of the target 10. What will be the final output?

hard

A. -1

B. 4

C. 5

D. 6

Solution

1. Step 1: Trace recursive calls for target 10

   Initial call: low=0, high=6, mid=3, arr[3]=7 < 10, search right half (4 to 6). Next mid=5, arr[5]=11 > 10, search left half (4 to 4). Next mid=4, arr[4]=9 < 10, search right half (5 to 4). Now low=5 > high=4, base case reached.

2. Step 2: Return -1 as target not found

   Since low > high, function returns -1 indicating target 10 is not in the list.

3. Final Answer:

   -1 -> Option A

4. Quick Check:

   Target 10 not in list returns -1 [OK]

Hint: If target not found, recursive calls end with -1 [OK]

Common Mistakes:

• Assuming closest smaller element index is returned
• Not handling base case properly
• Confusing index with value