Find Peak Element Using Binary Search in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the binary search with the correct initial left index.

DSA Java

int left = [1];

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

A1

B0

C-1

Dnums.length

Attempts:

3 left

💡 Hint

Common Mistakes

Starting left at 1 instead of 0.

Using negative indices which are invalid.

The binary search starts from the first index, which is 0.

2fill in blank

medium

Complete the code to calculate the middle index correctly.

DSA Java

int mid = left + ([1] - left) / 2;

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

Amid

Bleft

Cright

Dnums.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using mid instead of right in calculation.

Using nums.length which is out of current search range.

We calculate mid as the average of left and right to avoid overflow.

3fill in blank

hard

Fix the error in the condition to check if mid is a peak element.

DSA Java

if ((mid == 0 || nums[mid] > nums[mid - 1]) && (mid == nums.length - 1 || nums[mid] > [1])) {
    return mid;
}

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

Anums[mid + 1]

Bnums[mid - 1]

Cnums[mid + 2]

Dnums[mid]

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with nums[mid - 1] twice.

Using mid + 2 which may cause index out of bounds.

We compare nums[mid] with nums[mid + 1] to check the right neighbor.

4fill in blank

hard

Fill both blanks to update the search range correctly when the right neighbor is greater.

DSA Java

if (nums[mid] < nums[[1]]) {
    [2] = mid + 1;
} else {
    right = mid;
}

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

Amid + 1

Bmid - 1

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Updating right pointer instead of left.

Using mid - 1 which moves left pointer backward incorrectly.

If the right neighbor is greater, move left pointer to mid + 1 to search right side.

5fill in blank

hard

Fill all three blanks to complete the binary search method to find a peak element.

DSA Java

public int findPeakElement(int[] nums) {
    int left = [1], right = nums.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < nums[[2]]) {
            left = mid + 1;
        } else {
            right = [3];
        }
    }
    return left;
}

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

A0

Bmid + 1

Cmid

Dnums.length - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting left at 1 instead of 0.

Using wrong indices for comparison.

Updating right pointer incorrectly.

Initialize left to 0. Compare nums[mid] with nums[mid + 1]. Update right to mid when left side is greater or equal.

Practice

1. What is a peak element in an array when using binary search to find it?

easy

A. The smallest element in the array

B. An element that is greater than its neighbors

C. The first element of the array

D. An element equal to its neighbors

Solution

1. Step 1: Understand the definition of a peak element

   A peak element is one that is strictly greater than its neighbors on both sides (or just one side if at the boundary).

2. Step 2: Relate to binary search usage

   Binary search finds such an element by comparing mid elements with neighbors to decide which half to search next.

3. Final Answer:

   An element that is greater than its neighbors -> Option B

4. Quick Check:

   Peak element = greater than neighbors [OK]

Hint: Peak element is bigger than neighbors, not smallest [OK]

Common Mistakes:

• Confusing peak with minimum element
• Thinking peak must be at array ends only
• Assuming peak equals neighbors

2. Which of the following is the correct way to start the binary search for a peak element in Java?

easy

A. int left = 0, right = arr.length;

B. int left = 1, right = arr.length;

C. int left = 0, right = arr.length - 1;

D. int left = 1, right = arr.length - 1;

Solution

1. Step 1: Identify valid index range for binary search

   Array indices in Java go from 0 to length-1, so left should be 0 and right should be arr.length - 1.

2. Step 2: Check options for correct initialization

   int left = 0, right = arr.length - 1; correctly sets left=0 and right=arr.length-1, which covers the whole array.

3. Final Answer:

   int left = 0, right = arr.length - 1; -> Option C

4. Quick Check:

   Index range = 0 to length-1 [OK]

Hint: Array indices start at 0, end at length-1 [OK]

Common Mistakes:

• Starting right at arr.length causes out-of-bounds
• Starting left at 1 skips first element
• Using invalid index ranges

3. What will be the output index of the peak element for the array [1, 3, 20, 4, 1, 0] using binary search peak finding?

medium

A. 0

B. 1

C. 3

D. 2

Solution

1. Step 1: Identify peak elements in the array

   Array: [1, 3, 20, 4, 1, 0]. 20 at index 2 is greater than neighbors 3 and 4, so it's a peak.

2. Step 2: Binary search will find index 2 as peak

   Binary search compares mid elements and moves left or right until it finds 20 at index 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Peak at index 2 = 20 [OK]

Hint: Peak is local max, here 20 at index 2 [OK]

Common Mistakes:

• Choosing first or last element incorrectly
• Confusing peak with global max
• Ignoring neighbors comparison

4. Given this code snippet to find a peak element, what is the error?

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

medium

A. It may cause ArrayIndexOutOfBoundsException at arr[mid + 1]

B. It returns right instead of left

C. It uses wrong mid calculation causing infinite loop

D. It should compare arr[mid] with arr[mid - 1]

Solution

1. Step 1: Check boundary conditions for arr[mid + 1]

   If mid is at the last index, arr[mid + 1] access causes ArrayIndexOutOfBoundsException.

2. Step 2: Identify missing boundary check

   The code does not check if mid + 1 is within array bounds before accessing.

3. Final Answer:

   It may cause ArrayIndexOutOfBoundsException at arr[mid + 1] -> Option A

4. Quick Check:

   Accessing arr[mid+1] at end causes error [OK]

Hint: Check array bounds before accessing mid+1 [OK]

Common Mistakes:

• Ignoring array boundary checks
• Assuming mid+1 always valid
• Confusing left and right updates

5. You have an array [10, 20, 15, 2, 23, 90, 67]. Using binary search to find a peak element, which index will the algorithm return?

hard

A. 5

B. 6

C. 4

D. 1

Solution

1. Step 1: Identify all peak elements in the array

   Array: [10, 20, 15, 2, 23, 90, 67]. Peaks are 20 (index 1), 90 (index 5).

2. Step 2: Understand binary search behavior

   Binary search compares mid with neighbors and moves towards the side with higher neighbor. It will find 90 at index 5 as peak.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Peak found at index 5 = 90 [OK]

Hint: Binary search finds any peak, here index 5 with value 90 [OK]

Common Mistakes:

• Assuming only first peak is returned
• Confusing peak with global max
• Not tracing binary search steps carefully