Binary Search Recursive Approach in DSA Typescript - 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 search is successful.

beginner

Why must the input array be sorted for binary search to work?

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

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, reducing the problem size exponentially until the target is found or the search space is empty.

intermediate

How does recursion help in implementing binary search?

Recursion allows the function to call itself with a smaller search range, simplifying the code by handling the search in smaller parts until the base case is reached.

What should happen if the middle element equals the target in recursive binary search?

A Return -1

B Return the middle index

C Search the right half

D Search the left half

If the middle element matches the target, the search is successful and the function returns the middle index.

What is the first step in each recursive call of binary search?

A Calculate the middle index of the current search range

B Sort the array

C Return -1

D Swap elements

Each recursive call calculates the middle index to compare the target with the middle element.

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

A Reset the indices

B Continue searching

C The target is not found, return -1

D Return the start index

When start > end, the search range is empty, so the target is not in the array.

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

A Array must be sorted

B Search range indices must be valid

C Target must be comparable

D Array must have unique elements

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

What is the advantage of using recursion in binary search?

A Simplifies code by handling smaller subproblems

B Makes the search faster than iterative

C Uses more memory without benefit

D Avoids calculating middle index

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

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

Think about dividing the array and calling the function again with smaller parts.

Describe the base cases in recursive binary search and why they are important.

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 each element one by one from start to end

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

C. Sort the array after each recursive call

D. Use a queue to store elements for searching

Solution

1. Step 1: Understand binary search logic

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

2. Step 2: Apply recursion in binary search

   The recursive approach 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 correct half -> Option B

4. Quick Check:

   Binary search = divide and conquer [OK]

Hint: Remember: binary search splits array, then recurses [OK]

Common Mistakes:

• Thinking binary search checks every element
• Sorting array inside recursion
• Using linear search logic

2. Which of the following is the correct TypeScript function signature for a recursive binary search?

easy

A. function binarySearch(arr: number[], target: string): boolean

B. function binarySearch(arr: string[], target: number): number

C. function binarySearch(arr: number[], target: number, left: number, right: number): number

D. function binarySearch(arr: number[], target: number): void

Solution

1. Step 1: Check parameters needed for recursion

   Recursive binary search needs the array, target, and the current left and right indices to search between.

2. Step 2: Verify return type

   The function returns the index of the target if found, so the return type is number.

3. Final Answer:

   function binarySearch(arr: number[], target: number, left: number, right: number): number -> Option C

4. Quick Check:

   Parameters + return type match recursive binary search [OK]

Hint: Recursive binary search needs left and right indices [OK]

Common Mistakes:

• Missing left and right parameters
• Wrong return type (void or boolean)
• Mismatched array and target types

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

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if (left > right) return -1;
  const mid = Math.floor((left + right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, target, left, mid - 1);
  else return binarySearch(arr, target, mid + 1, right);
}

const nums = [2, 4, 6, 8, 10];
console.log(binarySearch(nums, 6, 0, nums.length - 1));

medium

A. 2

B. 1

C. -1

D. 3

Solution

1. Step 1: Identify middle index and compare

   Initial call: left=0, right=4, mid=2. arr[2] = 6 matches target 6.

2. Step 2: Return index when found

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

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Target found at index 2 [OK]

Hint: Check middle element first, then recurse [OK]

Common Mistakes:

• Miscomputing mid index
• Returning wrong index
• Confusing array values with indices

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

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if (left >= right) return -1;
  const mid = Math.floor((left + right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, target, left, mid - 1);
  else return binarySearch(arr, target, mid + 1, right);
}

medium

A. The base case condition should be left > right, not left >= right

B. The mid calculation is incorrect

C. The function should return boolean instead of number

D. The recursive calls have wrong parameters

Solution

1. Step 1: Analyze base case condition

   The base case currently returns -1 if left >= right, but it should allow left == right to check that element.

2. Step 2: Correct base case to left > right

   Changing to left > right ensures the search includes the last element before stopping.

3. Final Answer:

   The base case condition should be left > right, not left >= right -> Option A

4. Quick Check:

   Base case must allow left == right [OK]

Hint: Base case stops when left passes right, not equals [OK]

Common Mistakes:

• Stopping search too early with wrong base case
• Miscomputing mid index
• Wrong return type

5. Given a sorted array arr = [1, 3, 5, 7, 9, 11, 13], write a recursive binary search call to find the index of 7. What will be the sequence of mid indices checked?

hard

A. [3, 5]

B. [3, 1]

C. [3, 1, 2]

D. [3]

Solution

1. Step 1: Calculate initial mid index

   left=0, right=6, mid = floor((0+6)/2) = 3. arr[3] = 7 matches target immediately.

2. Step 2: No further recursive calls needed

   Since target found at first mid, no other mid indices are checked.

3. Final Answer:

   [3] -> Option D

4. Quick Check:

   Target found at first mid index 3 [OK]

Hint: First mid often finds target if array is balanced [OK]

Common Mistakes:

• Assuming multiple recursive calls always happen
• Miscomputing mid index
• Confusing indices with values