Binary Search as Divide and Conquer in DSA C++ - Build from Scratch

Binary Search as Divide and Conquer

📖 Scenario: You have a sorted list of book page numbers where a special note is hidden. You want to find the page number quickly using a method that splits the search area in half each time.

🎯 Goal: Build a C++ program that uses binary search to find a target page number in a sorted list of page numbers.

📋 What You'll Learn

Create a sorted vector of integers called pages with exact values

Create two integer variables left and right to mark the search range

Implement the binary search logic using a while loop and divide the search range

Print the index of the target page if found, or -1 if not found

💡 Why This Matters

🌍 Real World

Binary search is used in many applications like searching in phone books, dictionaries, or any sorted data to find information quickly.

💼 Career

Understanding binary search helps in software development roles where efficient data searching and algorithm optimization are important.

1

Create the sorted list of page numbers

Create a std::vector<int> called pages with these exact values: 2, 5, 8, 12, 16, 23, 38, 56, 72, 91

DSA C++

#include 
#include 

int main() {
    // Create the vector pages with the given values
    // Your code here
    return 0;
}

Hint

Use std::vector<int> pages = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}; to create the sorted list.

2

Set up the search range variables

Create two integer variables called left and right. Set left to 0 and right to the last index of pages (which is 9).

DSA C++

#include 
#include 

int main() {
    std::vector pages = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    // Create left and right variables for search range
    // Your code here
    return 0;
}

Hint

Set left to 0 and right to 9 because the vector has 10 elements indexed 0 to 9.

3

Implement the binary search logic

Create an integer variable target and set it to 23. Use a while loop with the condition left <= right. Inside the loop, calculate mid as (left + right) / 2. If pages[mid] equals target, break the loop. If pages[mid] is less than target, set left to mid + 1. Otherwise, set right to mid - 1. Also create an integer variable result initialized to -1 and update it to mid when the target is found.

DSA C++

#include 
#include 

int main() {
    std::vector pages = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int left = 0;
    int right = 9;
    // Implement binary search to find target 23
    // Your code here
    return 0;
}

Hint

Use a while loop to repeatedly check the middle element and adjust left or right until you find the target or the range is empty.

4

Print the search result

Print the value of result using std::cout. This will show the index of the target page if found, or -1 if not found.

DSA C++

#include 
#include 

int main() {
    std::vector pages = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int left = 0;
    int right = 9;
    int target = 23;
    int result = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (pages[mid] == target) {
            result = mid;
            break;
        } else if (pages[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    // Print the result
    // Your code here
    return 0;
}

Hint

Use std::cout << result << std::endl; to print the index.

Practice

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

easy

A. It divides the search space into two halves and discards one half each time.

B. It searches every element one by one until it finds the target.

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

D. It uses recursion to add elements to 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 continue searching based on the middle element.

2. Step 2: Identify the main action in binary search

   It discards the half where the target cannot be, reducing the search space quickly.

3. Final Answer:

   It divides the search space into two halves and discards one half each time. -> Option A

4. Quick Check:

   Divide and conquer = split and discard half [OK]

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

Common Mistakes:

• Thinking binary search checks every element
• Confusing binary search with linear search
• Assuming binary search sorts the array

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 why to avoid overflow

   Using (low + high) / 2 can cause overflow if low and high are large integers.

2. Step 2: Use safe middle calculation

   Calculating mid as low + (high - low) / 2 avoids overflow by subtracting before adding.

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
• Using subtraction incorrectly in mid calculation
• Multiplying low and high instead of adding

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

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

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

medium

A. 3

B. 4

C. -1

D. 2

Solution

1. Step 1: Trace the binary search calls

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

2. Step 2: Return the index found

   Since arr[2] == 6, the function returns 2 immediately.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Index of 6 in array = 2 [OK]

Hint: Check middle element first to find index quickly [OK]

Common Mistakes:

• Confusing index with value
• Not updating mid correctly
• Returning -1 when element is present

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

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

medium

A. The update low = mid should be low = mid + 1.

B. The loop condition should be low < high.

C. The mid calculation can cause overflow.

D. The function should return mid + 1 instead of mid.

Solution

1. Step 1: Analyze the update of low pointer

   When arr[mid] < x, low should move to mid + 1 to avoid infinite loop.

2. Step 2: Identify the infinite loop cause

   Setting low = mid keeps low same if mid equals low, causing infinite loop.

3. Final Answer:

   The update low = mid should be low = mid + 1. -> Option A

4. Quick Check:

   Increment low past mid to avoid infinite loop [OK]

Hint: Increment low by 1 after mid when moving right [OK]

Common Mistakes:

• Not incrementing low causing infinite loop
• Using wrong loop condition
• Ignoring overflow in mid calculation

5. You have a sorted array with duplicate elements: {1, 2, 2, 2, 3, 4}. How can you modify binary search to find the first occurrence of 2?

hard

A. Return immediately when 2 is found.

B. Keep searching left half even after finding 2 to find first occurrence.

C. Search right half after finding 2 to find last occurrence.

D. Use linear search instead of binary search.

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

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

3. Step 3: Stop when mid is first or left element is different

   Return mid if it is first element or previous element is different.

4. Final Answer:

   Keep searching left half even after finding 2 to find first occurrence. -> Option B

5. Quick Check:

   Find first occurrence by searching left after match [OK]

Hint: After match, move left to find first duplicate [OK]

Common Mistakes:

• Returning first found index without checking left
• Searching right half after finding target
• Using linear search unnecessarily