Find Peak Element Using Binary Search in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the peak element index in the array

What is the output index of the peak element for the given array using binary search?

DSA Java

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

    public static void main(String[] args) {
        int[] nums = {1, 3, 20, 4, 1, 0};
        System.out.println(findPeakElement(nums));
    }
}

A 2

B 1

C 3

D 5

💡 Hint

Check where the array value is greater than its next element to find the peak.

The binary search compares mid element with mid+1 element. If mid is greater, the peak lies on the left side including mid. Otherwise, it lies on the right side. The loop ends when left == right, which is the peak index.

❓ Predict Output

intermediate

Output of peak element index for a strictly increasing array

What index will the binary search return as the peak element for this strictly increasing array?

DSA Java

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

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6};
        System.out.println(findPeakElement(nums));
    }
}

A 4

B 0

C 3

D 5

💡 Hint

In a strictly increasing array, the last element is the peak.

Since the array is strictly increasing, each element is less than the next. The binary search moves right until it reaches the last index, which is the peak.

🔧 Debug

advanced

Identify the error in the binary search peak element code

What error will this code produce when run?

DSA Java

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

    public static void main(String[] args) {
        int[] nums = {1, 3};
        System.out.println(findPeakElement(nums));
    }
}

A Infinite loop

B ArrayIndexOutOfBoundsException

C Returns index 1 correctly

D Compilation error

💡 Hint

Check the condition and indexing inside the loop carefully.

The code accesses nums[mid + 1] without ensuring mid+1 is within bounds. When mid is the last index, this causes ArrayIndexOutOfBoundsException.

🧠 Conceptual

advanced

Why does binary search work for finding a peak element?

Which statement best explains why binary search can find a peak element in an unsorted array?

A Because at least one peak exists and comparing mid with mid+1 helps decide which half contains a peak.

B Because the array is always sorted, so binary search applies directly.

C Because the peak is always at the middle of the array.

D Because binary search checks every element one by one to find the peak.

💡 Hint

Think about how the comparison between mid and mid+1 guides the search.

The array may not be sorted, but a peak element always exists. Comparing nums[mid] and nums[mid+1] tells which side has a peak, allowing binary search to discard half the array each time.

❓ Predict Output

expert

Find peak element index in array with multiple peaks

What is the output index of the peak element for the given array using the binary search method?

DSA Java

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

    public static void main(String[] args) {
        int[] nums = {1, 3, 2, 5, 4, 6, 1};
        System.out.println(findPeakElement(nums));
    }
}

A 5

B 3

C 1

D 6

💡 Hint

The binary search returns one peak, not necessarily the highest peak.

The binary search finds a peak by comparing mid and mid+1. It will return index 1 where value 3 is a peak (greater than neighbors 1 and 2).

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