Binary Search as Divide and Conquer in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Recursive Binary Search Call

What is the output of the following C code snippet that performs a recursive binary search on a sorted array?

Assume the array is sorted in ascending order.

DSA C

int binarySearch(int arr[], int left, int right, int x) {
    if (right >= left) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == x) return mid;
        if (arr[mid] > x) return binarySearch(arr, left, mid - 1, x);
        return binarySearch(arr, mid + 1, right, x);
    }
    return -1;
}

int main() {
    int arr[] = {2, 4, 6, 8, 10, 12, 14};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 10;
    int result = binarySearch(arr, 0, n - 1, x);
    printf("%d", result);
    return 0;
}

A 4

B 3

C -1

D 5

💡 Hint

Remember array indexing starts at 0. Find the position of 10 in the array.

The array is {2,4,6,8,10,12,14}. The element 10 is at index 4 (0-based). The binary search returns the index where the element is found.

🧠 Conceptual

intermediate

Divide and Conquer Principle in Binary Search

Which statement best describes how binary search uses the divide and conquer approach?

A It divides the array into two halves and recursively searches only the half that may contain the target.

B It divides the array into multiple parts and searches all parts simultaneously.

C It searches the entire array linearly after dividing it into halves.

D It combines all elements before searching for the target.

💡 Hint

Think about how binary search reduces the search space each step.

Binary search splits the array into two halves and only continues searching the half where the target could be, reducing the problem size each time.

❓ Predict Output

advanced

Output of Iterative Binary Search with Missing Element

What is the output of the following iterative binary search code when searching for 7 in the given array?

DSA C

int binarySearchIter(int arr[], int n, int x) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == x) return mid;
        else if (arr[mid] < x) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 5, 9, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 7;
    int result = binarySearchIter(arr, n, x);
    printf("%d", result);
    return 0;
}

A 0

B 2

C 3

D -1

💡 Hint

7 is not in the array. What does the function return when the element is not found?

Since 7 is not present in the array, the binary search returns -1 indicating the element is not found.

🔧 Debug

advanced

Identify the Logical Error in Binary Search

Consider this binary search code snippet. What logical error causes it to fail for some inputs?

DSA C

int binarySearch(int arr[], int left, int right, int x) {
    if (left > right) return -1;
    int mid = (left + right) / 2;
    if (arr[mid] == x) return mid;
    if (arr[mid] < x) return binarySearch(arr, mid, right, x);
    else return binarySearch(arr, left, mid - 1, x);
}

A The base case condition should be 'left >= right' instead of 'left > right'.

B The recursive call uses 'mid' instead of 'mid + 1' when searching the right half, causing infinite recursion.

C The mid calculation should be 'left - right' instead of 'left + right'.

D The function should return 'left' instead of '-1' when element is not found.

💡 Hint

Check how the search space changes in recursive calls.

Using 'mid' instead of 'mid + 1' when searching the right half causes the same middle index to be searched repeatedly, leading to infinite recursion.

🧠 Conceptual

expert

Time Complexity of Binary Search in Worst Case

What is the worst-case time complexity of binary search on a sorted array of size n, and why?

A O(1), because it directly jumps to the middle element.

B O(n), because it may need to check every element.

C O(log n), because the search space halves with each step.

D O(n log n), because it divides and sorts the array first.

💡 Hint

Think about how many times you can divide n by 2 until you reach 1.

Binary search halves the search space each step, so it takes about log base 2 of n steps in the worst case.

Practice

1. What is the main idea behind Binary Search as a divide and conquer algorithm?

easy

A. It searches every element one by one until the target is found.

B. It divides the search range in half each time to find the target efficiently.

C. It sorts the array before searching for the target.

D. It uses recursion to add all elements in the array.

Solution

1. Step 1: Understand divide and conquer in binary search

   Binary search splits the array into two halves and decides which half to search next.

2. Step 2: Identify the efficiency of halving the search space

   By halving the search space each time, it quickly narrows down the target location.

3. Final Answer:

   It divides the search range in half each time to find the target efficiently. -> Option B

4. Quick Check:

   Divide and conquer = halving search space [OK]

Hint: Binary search halves the search space each step [OK]

Common Mistakes:

• Thinking binary search checks every element
• Confusing binary search with sorting
• Believing binary search sums elements

2. Which of the following is the correct syntax to calculate the middle index in binary search in C?

easy

A. int mid = (low + high) / 2;

B. int mid = (low * high) / 2;

C. int mid = low + (high - low) / 2;

D. int mid = (low - high) / 2;

Solution

1. Step 1: Understand safe middle index calculation

   Using low + (high - low) / 2 prevents integer overflow when low and high are large.

2. Step 2: Compare with other options

   int mid = (low + high) / 2; can overflow if low + high exceeds integer limit; options B and C are incorrect formulas.

3. Final Answer:

   int mid = low + (high - low) / 2; -> Option C

4. Quick Check:

   Safe mid calculation = low + (high - low)/2 [OK]

Hint: Use low + (high - low)/2 to avoid overflow [OK]

Common Mistakes:

• Using (low + high)/2 causing overflow
• Subtracting incorrectly in mid calculation
• Multiplying low and high instead of adding

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

int arr[] = {2, 4, 6, 8, 10};
int low = 0, high = 4, target = 6;
while (low <= high) {
  int mid = low + (high - low) / 2;
  if (arr[mid] == target) {
    printf("%d", mid);
    break;
  } else if (arr[mid] < target) {
    low = mid + 1;
  } else {
    high = mid - 1;
  }
}

medium

A. 2

B. 3

C. 1

D. 4

Solution

1. Step 1: Trace the binary search steps

   Initial low=0, high=4, mid=2. arr[2]=6 matches target 6.

2. Step 2: Print the mid index

   Since arr[mid] == target, the code prints 2 and breaks the loop.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Target found at index 2 [OK]

Hint: Check mid index value matches target first [OK]

Common Mistakes:

• Not updating low and high correctly
• Confusing index with value
• Off-by-one errors in mid calculation

4. Identify the error in this binary search code snippet and choose the correct fix:

int binarySearch(int arr[], int low, int high, int target) {
  while (low < high) {
    int mid = low + (high - low) / 2;
    if (arr[mid] == target) return mid;
    else if (arr[mid] < target) low = mid + 1;
    else high = mid - 1;
  }
  return -1;
}

medium

A. Change while condition to low <= high

B. Change mid calculation to (low + high) / 2

C. Remove else if and use only if statements

D. Return 0 instead of -1 when not found

Solution

1. Step 1: Analyze the loop condition

   The loop uses while (low < high), which misses checking when low equals high.

2. Step 2: Correct the loop condition

   Changing to while (low <= high) ensures the last element is checked.

3. Final Answer:

   Change while condition to low <= high -> Option A

4. Quick Check:

   Loop must include low == high to check all elements [OK]

Hint: Use while(low <= high) to include all elements [OK]

Common Mistakes:

• Using < instead of <= in loop condition
• Incorrect mid calculation causing overflow
• Returning wrong value when target not found

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

hard

A. Use linear search instead of binary search.

B. Return the first found index immediately without further search.

C. Search only the right half after finding the target.

D. After finding target, continue searching left half to find earlier occurrence.

Solution

1. Step 1: Understand duplicates in binary search

   Standard binary search returns any occurrence, not necessarily the first.

2. Step 2: Modify search to find first occurrence

   After finding target at mid, continue searching left half to check for earlier occurrences.

3. Final Answer:

   After finding target, continue searching left half to find earlier occurrence. -> Option D

4. Quick Check:

   Find first occurrence by searching left after match [OK]

Hint: Search left half after match to find first occurrence [OK]

Common Mistakes:

• Stopping at first found index ignoring duplicates
• Searching right half instead of left after match
• Switching to linear search unnecessarily