Binary Search Iterative Approach in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Binary Search on Sorted Array

What is the output of the following Java code that performs an iterative binary search for the value 7 in the array?

DSA Java

public class Main {
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11};
        System.out.println(binarySearch(arr, 7));
    }
}

A 2

B 3

C -1

D 4

💡 Hint

Remember that array indices start at 0 and the array is sorted.

The value 7 is at index 3 in the array. The binary search finds it and returns the index.

❓ Predict Output

intermediate

Binary Search Result When Target Not Present

What will be the output of this Java code when searching for 8 in the given sorted array?

DSA Java

public class Main {
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 6, 10, 12};
        System.out.println(binarySearch(arr, 8));
    }
}

A 0

B 2

C -1

D 3

💡 Hint

If the target is not found, the function returns -1.

Since 8 is not in the array, the binary search returns -1 indicating not found.

🔧 Debug

advanced

Identify the Error in Binary Search Implementation

What error will this Java code produce when running the binary search for target 11?

DSA Java

public class Main {
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9};
        System.out.println(binarySearch(arr, 11));
    }
}

A Returns -1

B Infinite loop

C Compilation error

D ArrayIndexOutOfBoundsException

💡 Hint

Check the initial value of the right pointer and array indexing.

The right pointer is set to arr.length which is out of bounds for indexing, causing ArrayIndexOutOfBoundsException.

🧠 Conceptual

advanced

Number of Iterations in Binary Search

Given a sorted array of 64 elements, what is the maximum number of iterations the iterative binary search algorithm will perform to find a target or conclude it is not present?

A 7

B 6

C 8

D 64

💡 Hint

Binary search halves the search space each iteration.

Binary search takes at most log2(n) + 1 iterations. For 64 elements, log2(64) = 6, so max iterations = 7.

🚀 Application

expert

Find Insert Position Using Iterative Binary Search

What is the output of this Java code that uses iterative binary search to find the insert position for target 8 in a sorted array?

DSA Java

public class Main {
    public static int searchInsert(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 6, 9};
        System.out.println(searchInsert(arr, 8));
    }
}

A 4

B 3

C 5

D -1

💡 Hint

If target is not found, the function returns the index where it can be inserted to keep array sorted.

8 is not in the array. It should be inserted at index 4 to keep the array sorted.

Practice

1. What is the main purpose of the mid variable in the iterative binary search algorithm?

easy

A. To find the middle index of the current search range

B. To store the target value to search

C. To keep track of the number of iterations

D. To hold the final result index

Solution

1. Step 1: Understand the role of mid in binary search

   The mid variable calculates the middle index between low and high pointers to split the search range.

2. Step 2: Purpose of mid

   It helps decide whether to search the left or right half by comparing the middle element with the target.

3. Final Answer:

   To find the middle index of the current search range -> Option A

4. Quick Check:

   mid = middle index [OK]

Hint: Mid splits search range to half each step [OK]

Common Mistakes:

• Confusing mid with target value
• Thinking mid counts iterations
• Assuming mid stores final answer

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

easy

A. mid = low + (high - low) / 2

B. mid = (low + high) / 2

C. mid = (low - high) / 2

D. mid = (low * high) / 2

Solution

1. Step 1: Understand integer overflow risk

   Adding low and high directly can exceed integer limits if both are large.

2. Step 2: Safe calculation method

   Using low + (high - low) / 2 prevents overflow by subtracting before adding.

3. Final Answer:

   mid = low + (high - low) / 2 -> Option A

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
• Using subtraction incorrectly
• Multiplying low and high

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

int[] arr = {2, 4, 6, 8, 10};
int target = 6;
int low = 0, high = arr.length - 1;
int result = -1;
while (low <= high) {
  int mid = low + (high - low) / 2;
  if (arr[mid] == target) {
    result = mid;
    break;
  } else if (arr[mid] < target) {
    low = mid + 1;
  } else {
    high = mid - 1;
  }
}
System.out.println(result);

medium

A. 4

B. 3

C. 2

D. -1

Solution

1. Step 1: Trace the binary search steps

   Initial low=0, high=4, mid=2. arr[2]=6 equals target 6, so result=2 and loop breaks.

2. Step 2: Output the result

   Result is 2, which is the index of target 6 in the array.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Index of 6 in arr = 2 [OK]

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

Common Mistakes:

• Confusing index with value
• Not breaking loop on match
• Incorrect mid calculation

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

int binarySearch(int[] arr, int target) {
  int low = 0, high = arr.length - 1;
  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. Remove else if and use only if statements

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

C. Return low instead of -1 at the end

D. Change while condition to low <= high

Solution

1. Step 1: Analyze loop condition

   The condition low < high misses the case when low equals high, possibly skipping the last element.

2. Step 2: Correct loop condition

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

3. Final Answer:

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

4. Quick Check:

   Loop must include low == high [OK]

Hint: Use <= to include last element in search [OK]

Common Mistakes:

• Using < instead of <= in loop
• Incorrect mid calculation
• Returning wrong index on failure

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

hard

A. When arr[mid] == target, return mid immediately

B. When arr[mid] == target, update result and move high to mid - 1

C. When arr[mid] == target, move low to mid + 1

D. Ignore duplicates and return any matching index

Solution

1. Step 1: Understand duplicates in binary search

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

2. Step 2: Modify search to find first occurrence

   When arr[mid] == target, store mid as potential answer and continue searching left by setting high = mid - 1.

3. Final Answer:

   When arr[mid] == target, update result and move high to mid - 1 -> Option B

4. Quick Check:

   Move left on match to find first occurrence [OK]

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

Common Mistakes:

• Returning immediately on first match
• Moving right on match
• Ignoring duplicates