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

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the peak element index in the array

What is the output of the following JavaScript code that finds a peak element index using binary search?

DSA Javascript

function findPeakElement(nums) {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] > nums[mid + 1]) {
      right = mid;
    } else {
      left = mid + 1;
    }
  }
  return left;
}

console.log(findPeakElement([1, 3, 20, 4, 1, 0]));

A 2

B 3

C 1

D 5

💡 Hint

Think about how the binary search narrows down the peak by comparing mid and mid+1 elements.

The function uses binary search to find a peak element index. It compares nums[mid] and nums[mid+1]. If nums[mid] is greater, the peak lies on the left side including mid, so right moves to mid. Otherwise, the peak lies on the right side excluding mid, so left moves to mid+1. Eventually, left equals right at the peak index.

❓ Predict Output

intermediate

Output of peak element finder on a strictly increasing array

What will be the output of the peak element finder function when the input array is strictly increasing?

DSA Javascript

function findPeakElement(nums) {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] > nums[mid + 1]) {
      right = mid;
    } else {
      left = mid + 1;
    }
  }
  return left;
}

console.log(findPeakElement([1, 2, 3, 4, 5]));

A 4

B 0

C 2

D 3

💡 Hint

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

Since the array is strictly increasing, each element is smaller than the next. The binary search will keep moving left to mid+1 until it reaches the last index, which is the peak.

🔧 Debug

advanced

Identify the error in the peak element finder code

What error will the following code produce when run, and why?

DSA Javascript

function findPeakElement(nums) {
  let left = 0, right = nums.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] > nums[mid + 1]) {
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }
  return left;
}

console.log(findPeakElement([1, 2, 3, 1]));

A SyntaxError

B Returns 2 correctly

C TypeError: Cannot read property '1' of undefined

D Infinite loop

💡 Hint

Check the loop condition and the index used inside the loop.

The loop condition 'left <= right' allows mid to reach the last index. Then nums[mid + 1] accesses out of bounds causing a TypeError.

🧠 Conceptual

advanced

Why binary search works for finding a peak element

Why does the binary search approach correctly find a peak element in an unsorted array where adjacent elements are not equal?

A Because the peak is always at the start or end of the array.

B Because the array is sorted, so the middle element is always a peak.

C Because the algorithm checks every element sequentially until it finds a peak.

D Because at least one side of mid must contain a peak due to the array's property, allowing us to discard half each time.

💡 Hint

Think about the slope direction at mid compared to mid+1.

If nums[mid] > nums[mid+1], a peak must exist on the left side including mid. Otherwise, a peak exists on the right side. This property allows binary search to discard half the array each step.

❓ Predict Output

expert

Output of peak element finder on array with multiple peaks

What is the output index of the peak element finder function when the input array has multiple peaks?

DSA Javascript

function findPeakElement(nums) {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] > nums[mid + 1]) {
      right = mid;
    } else {
      left = mid + 1;
    }
  }
  return left;
}

console.log(findPeakElement([1, 3, 2, 4, 1, 0]));

A 1

B 3

C 2

D 4

💡 Hint

The function returns one peak index, not necessarily the first or last peak.

The binary search narrows down to one peak. In this array, indices 1 and 3 are peaks. The algorithm returns index 3 because of how it compares mid and mid+1.