Binary Search Iterative Approach in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the middle index in the binary search loop.

DSA C++

int mid = (low [1] high) / 2;

Drag options to blanks, or click blank then click option'

A+

B*

C-

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Using multiplication instead of addition.

Dividing before adding.

The middle index is calculated by adding low and high, then dividing by 2.

2fill in blank

medium

Complete the code to update the low index when the target is greater than the middle element.

DSA C++

if (arr[mid] < target) {
    low = [1];
}

Drag options to blanks, or click blank then click option'

Amid + 1

Bmid

Clow + 1

Dhigh

Attempts:

3 left

💡 Hint

Common Mistakes

Setting low to mid instead of mid + 1.

Setting low to high.

Not updating low at all.

When the target is greater than the middle element, we move low to mid + 1 to search the right half.

3fill in blank

hard

Fix the error in the loop condition to correctly run the binary search.

DSA C++

while (low [1] high) {
    int mid = (low + high) / 2;
    // rest of code
}

Drag options to blanks, or click blank then click option'

A>

B<=

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using only less than, which misses the last element.

Using greater than or equal, which never runs.

Using greater than, which never runs.

The loop should continue while low is less than or equal to high to cover all elements.

4fill in blank

hard

Fill both blanks to correctly update the high index when the target is less than the middle element.

DSA C++

if (target [1] arr[mid]) {
    high = [2];
}

Drag options to blanks, or click blank then click option'

A<

B>

Cmid - 1

Dmid + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using greater than instead of less than in comparison.

Setting high to mid + 1 instead of mid - 1.

Not updating high at all.

If the target is less than the middle element, we move high to mid - 1 to search the left half.

5fill in blank

hard

Fill all three blanks to complete the binary search function that returns the index or -1 if not found.

DSA C++

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

Drag options to blanks, or click blank then click option'

A-

B<=

Cmid

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Setting high to size instead of size - 1.

Using less than instead of less than or equal in loop.

Returning low or high instead of mid when found.

We set high to size - 1 because array indices start at 0. The loop runs while low is less than or equal to high. When found, return mid index.

Practice

1. What is the main purpose of the binarySearchIterative function in the iterative binary search approach?

easy

A. To find the position of a target value in a sorted array

B. To sort an unsorted array

C. To reverse the elements of an array

D. To count the number of elements in an array

Solution

1. Step 1: Understand the function goal

   The binary search function is designed to locate a target value within a sorted array efficiently.

2. Step 2: Identify the operation performed

   It repeatedly divides the search interval in half to find the target's position or determine it is not present.

3. Final Answer:

   To find the position of a target value in a sorted array -> Option A

4. Quick Check:

   Binary search locates target index [OK]

Hint: Binary search finds target index in sorted array fast [OK]

Common Mistakes:

• Thinking binary search sorts the array
• Confusing binary search with linear search
• Assuming it works on unsorted arrays

2. Which of the following is the correct syntax to calculate the middle index in an iterative binary search to avoid overflow?

easy

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

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

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

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

Solution

1. Step 1: Understand overflow risk in mid calculation

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

2. Step 2: Use safe formula to avoid overflow

   The formula low + (high - low) / 2 calculates mid without adding large numbers directly.

3. Final Answer:

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

4. Quick Check:

   Safe mid calculation avoids overflow [OK]

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

Common Mistakes:

• Using (low + high)/2 causing overflow
• Subtracting incorrectly in mid calculation
• Mixing up low and high in formula

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

int arr[] = {2, 4, 6, 8, 10};
int n = 5;
int target = 6;
int result = binarySearchIterative(arr, n, target);
std::cout << result << std::endl;

// Assume binarySearchIterative is correctly implemented iterative binary search

medium

A. -1

B. 2

C. 3

D. 1

Solution

1. Step 1: Identify the target and array

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

2. Step 2: Find the index of target using binary search

   6 is at index 2 (0-based indexing) in the array.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Index of 6 in array = 2 [OK]

Hint: Remember array indexing starts at 0 [OK]

Common Mistakes:

• Confusing index with value
• Using 1-based indexing instead of 0-based
• Assuming target not found returns 0

4. Identify the error in the following iterative binary search code snippet:

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

medium

A. The mid calculation can cause integer overflow

B. The loop condition should be low < high

C. The return value should be 0 when not found

D. The array should be unsorted for binary search

Solution

1. Step 1: Review mid calculation

   Mid is calculated as (low + high) / 2 which can overflow if low and high are large.

2. Step 2: Suggest safer mid calculation

   Use low + (high - low) / 2 to avoid overflow in mid calculation.

3. Final Answer:

   The mid calculation can cause integer overflow -> Option A

4. Quick Check:

   Mid calculation overflow risk = true [OK]

Hint: Use safe mid formula to avoid overflow [OK]

Common Mistakes:

• Changing loop condition incorrectly
• Returning 0 instead of -1 when not found
• Assuming binary search works on unsorted arrays

5. Given a sorted array arr = {1, 3, 5, 7, 9, 11, 13}, how many iterations will the iterative binary search take to find the target value 7?

hard

A. 4

B. 2

C. 3

D. 1

Solution

1. Step 1: Initialize low and high pointers

   low = 0, high = 6 (array length - 1)

2. Step 2: Trace each iteration to find 7

   Iteration 1: mid = 0 + (6-0)/2 = 3, arr[3] = 7 (target found at first check)

3. Step 3: Count iterations

   Only 1 iteration is needed because target is found immediately at mid index 3.

4. Final Answer:

   1 -> Option D

5. Quick Check:

   Target found at first mid check [OK]

Hint: Count mid calculations until target found [OK]

Common Mistakes:

• Assuming always 3 iterations for any search
• Counting array length instead of iterations
• Forgetting zero-based indexing