Binary Search Recursive Approach in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the binary search algorithm?

Binary search works by repeatedly dividing a sorted list in half to find a target value quickly. It compares the target with the middle element and decides which half to search next.

beginner

In the recursive binary search, what are the base cases?

The base cases are when the search range is empty (start index > end index), meaning the target is not found, or when the middle element equals the target, meaning the target is found.

beginner

Why must the list be sorted for binary search to work?

Because binary search decides which half to search based on comparisons, the list must be sorted to ensure that all smaller elements are on one side and larger on the other.

intermediate

What parameters are typically passed in a recursive binary search function?

Usually, the list, the target value, the start index, and the end index are passed to keep track of the current search range.

intermediate

How does the recursive binary search reduce the problem size at each step?

It calls itself on either the left half or the right half of the current list segment, effectively halving the search space each time.

What is the time complexity of binary search on a sorted list?

A O(log n)

B O(n)

C O(n log n)

D O(1)

Binary search divides the search space in half each time, leading to a logarithmic time complexity O(log n).

In recursive binary search, what happens if the middle element is less than the target?

A Search the left half

B Return -1 immediately

C Return the middle index

D Search the right half

If the middle element is less than the target, the target must be in the right half, so the search continues there.

Which of these is NOT a parameter in a typical recursive binary search function?

A The current index of the target

B The target value

C The list to search

D Start and end indices of the search range

The current index of the target is not known beforehand; the function searches to find it.

What should the recursive binary search return if the target is not found?

A The index of the middle element

B -1 or a special value indicating not found

C The start index

D The end index

Returning -1 or a special value indicates the target is not present in the list.

Why is recursion useful in binary search?

A It makes the search slower

B It avoids using any parameters

C It automatically handles dividing the problem into smaller parts

D It sorts the list

Recursion naturally breaks the problem into smaller parts, making the code simpler and easier to understand.

Explain how recursive binary search works step-by-step on a sorted list.

Think about how the list is divided and how the function calls itself.

Describe the importance of base cases in recursive binary search and what they represent.

Base cases tell the function when to stop searching.

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