Binary Search Recursive Approach in DSA C++ - 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 input array be sorted for binary search to work?

Binary search relies on the order of elements to decide which half to search next. If the array is not sorted, the algorithm cannot correctly eliminate half of the elements each time.

intermediate

What is the time complexity of binary search and why?

The time complexity is O(log n) because each step cuts the search space in half, so the number of steps grows logarithmically with the size of the input.

intermediate

Show the recursive call structure for binary search on array [2,4,6,8,10] searching for 8.

1. Check middle element (6 at index 2), 8 > 6, search right half [8,10].
2. Check middle element (8 at index 3), found target.
Recursive calls reduce search space until target is found.

What should happen if the start index becomes greater than the end index in recursive binary search?

A Return the end index

B Continue searching the entire array

C Return the start index

D Return -1 indicating target not found

When start > end, it means the search space is empty and the target is not present.

Which of these is NOT a requirement for binary search to work correctly?

A Array must have unique elements

B Array must be sorted

C Access to middle element in constant time

D Target value to search

Binary search works with duplicates as well; uniqueness is not required.

What is the middle index calculation to avoid overflow in binary search?

A start + (end - start) / 2

B end - (start / 2)

C (start + end) / 2

D start * end / 2

Using start + (end - start) / 2 prevents integer overflow.

If the middle element is less than the target, what part of the array does recursive binary search explore next?

A Left half

B No further search

C Right half

D Entire array again

If middle element < target, search continues in the right half.

What is the worst-case time complexity of recursive binary search?

A O(n)

B O(log n)

C O(n log n)

D O(1)

Binary search halves the search space each time, leading to O(log n) complexity.

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

Think about how the problem size reduces each call.

Describe why binary search is more efficient than linear search on sorted arrays.

Focus on how many elements are checked in each approach.

Practice

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

easy

A. Use recursion to reverse the array before searching

B. Divide the array into halves and search recursively in the relevant half

C. Sort the array recursively before searching

D. Search every element one by one recursively

Solution

1. Step 1: Understand binary search logic

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

2. Step 2: Apply recursion in binary search

   Recursion calls the same function on the half where the target might be, reducing the search space each time.

3. Final Answer:

   Divide the array into halves and search recursively in the relevant half -> Option B

4. Quick Check:

   Binary search = divide and conquer [OK]

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

Common Mistakes:

• Searching all elements recursively instead of half
• Sorting inside the search function
• Not reducing search space correctly

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

easy

A. if (start > end) return -1;

B. if (start == end) return start;

C. if (start < end) return -1;

D. if (start == 0) return 0;

Solution

1. Step 1: Identify when search should stop

   The search should stop when the start index is greater than the end index, meaning the element is not found.

2. Step 2: Confirm base case condition

   Checking if start > end returns -1 to indicate the target is missing.

3. Final Answer:

   if (start > end) return -1; -> Option A

4. Quick Check:

   Base case = start > end means not found [OK]

Hint: Stop when start passes end, return -1 [OK]

Common Mistakes:

• Using start == end as base case incorrectly
• Returning wrong index when not found
• Confusing start and end conditions

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

int binarySearch(int arr[], int start, int end, int target) {
  if (start > end) return -1;
  int mid = start + (end - start) / 2;
  if (arr[mid] == target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, start, mid - 1, target);
  else return binarySearch(arr, mid + 1, end, target);
}

int main() {
  int arr[] = {2, 4, 6, 8, 10};
  int index = binarySearch(arr, 0, 4, 6);
  std::cout << index;
  return 0;
}

medium

A. 2

B. 1

C. 3

D. -1

Solution

1. Step 1: Identify the target and array

   The array is {2,4,6,8,10} and target is 6.

2. Step 2: Trace recursive calls

   First mid = 2 (index 2), arr[2] = 6 matches target, so return 2 immediately.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Target 6 found at index 2 [OK]

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

Common Mistakes:

• Confusing index with value
• Off-by-one errors in mid calculation
• Not returning correct index

4. Find the error in this recursive binary search function:

int binarySearch(int arr[], int start, int end, int target) {
  if (start >= end) return -1;
  int mid = (start + end) / 2;
  if (arr[mid] == target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, start, mid - 1, target);
  else return binarySearch(arr, mid + 1, end, target);
}

medium

A. Mid calculation should be start - end instead of start + end

B. Return value should be target, not index

C. Base case condition should be start > end, not start >= end

D. Recursive calls should swap start and end

Solution

1. Step 1: Analyze base case condition

   The base case incorrectly uses start >= end, which misses checking when start == end.

2. Step 2: Correct base case for full search

   It should be start > end to allow checking the last element at start == end.

3. Final Answer:

   Base case condition should be start > end, not start >= end -> Option C

4. Quick Check:

   Base case = start > end to stop [OK]

Hint: Base case must allow start == end check [OK]

Common Mistakes:

• Using >= instead of > in base case
• Wrong mid calculation formula
• Returning wrong values

5. Given a sorted array with possible duplicate elements, how can you modify the recursive binary search to find the first occurrence of a target value?

hard

A. Use linear search after binary search to find first occurrence

B. Return mid immediately when arr[mid] == target

C. Search right half only when arr[mid] == target

D. When arr[mid] == target, continue searching left half to find earlier occurrence

Solution

1. Step 1: Understand duplicates in sorted array

   Duplicates mean target can appear multiple times; we want the first index.

2. Step 2: Modify recursive search on match

   When arr[mid] == target, recursively search left half to check for earlier occurrence, else return mid.

3. Step 3: Implement logic

   If left recursive call returns valid index, return it; otherwise return mid.

4. Final Answer:

   When arr[mid] == target, continue searching left half to find earlier occurrence -> Option D

5. Quick Check:

   Find first occurrence = search left on match [OK]

Hint: On match, search left half to find first occurrence [OK]

Common Mistakes:

• Returning first found index without checking left side
• Searching right half on match
• Using linear search unnecessarily