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.

Practice

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

easy

A. An element that is greater than its neighbors

B. The smallest element in the array

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 one side if at the boundary).

2. Step 2: Compare options with the definition

   Only An element that is greater than its neighbors matches this definition exactly.

3. Final Answer:

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

4. Quick Check:

   Peak element = greater than neighbors [OK]

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

Common Mistakes:

• Thinking peak means smallest element
• Confusing peak with first or last element
• Assuming peak equals neighbors

2. Which of the following is the correct way to calculate the middle index mid in binary search in JavaScript?

easy

A. const mid = (left + right) / 2;

B. const mid = Math.ceil((left + right) / 2);

C. const mid = Math.floor((left + right) / 2);

D. const mid = left + right / 2;

Solution

1. Step 1: Understand integer division in JavaScript

   JavaScript division returns a float, so we use Math.floor to get an integer index.

2. Step 2: Check each option

   const mid = Math.floor((left + right) / 2); uses Math.floor on the average of left and right, which is correct for binary search.

3. Final Answer:

   const mid = Math.floor((left + right) / 2); -> Option C

4. Quick Check:

   Use Math.floor for integer mid index [OK]

Hint: Use Math.floor((left + right) / 2) for mid index [OK]

Common Mistakes:

• Not using Math.floor causes float index
• Using only division without parentheses
• Incorrect operator precedence in calculation

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

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

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

medium

A. 3

B. 1

C. 2

D. 0

Solution

1. Step 1: Trace the binary search steps on array [1,3,2,4,1]

   Initial left=0, right=4. mid=2 (value=2). Compare nums[2]=2 and nums[3]=4. Since 2 < 4, left=mid+1=3.

2. Step 2: Next iteration with left=3, right=4

   mid=3 (value=4). Compare nums[3]=4 and nums[4]=1. Since 4 > 1, right=mid=3.

3. Step 3: Loop ends as left=right=3

   Return left=3, which is index of peak element 4.

4. Final Answer:

   3 -> Option A

5. Quick Check:

   Peak index = 3 [OK]

Hint: Compare mid and mid+1 to decide left or right [OK]

Common Mistakes:

• Returning value instead of index
• Not updating left or right correctly
• Confusing mid calculation

4. Identify the bug in this binary search code to find a peak element:

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

medium

A. The comparison should be nums[mid] > nums[mid + 1] instead of <.

B. The mid calculation is incorrect.

C. The return statement should return right instead of left.

D. The loop condition should be left < right instead of <=.

Solution

1. Step 1: Analyze the loop condition

   The loop uses left <= right, which can cause mid+1 to go out of bounds when mid = right.

2. Step 2: Correct loop condition for safe mid+1 access

   Changing to left < right ensures mid+1 is always valid inside the loop.

3. Final Answer:

   The loop condition should be left < right instead of <=. -> Option D

4. Quick Check:

   Loop condition left < right avoids out-of-bounds [OK]

Hint: Use left < right to avoid mid+1 overflow [OK]

Common Mistakes:

• Using <= causes index out of range error
• Changing mid calculation unnecessarily
• Returning wrong index

5. Given a strictly increasing then strictly decreasing array nums, how can you modify the binary search to find the peak element efficiently?
Choose the best approach.

hard

A. Use binary search comparing nums[mid] and nums[mid-1], move left or right accordingly.

B. Use binary search comparing nums[mid] and nums[mid+1], move left or right accordingly.

C. Scan the array linearly from start to find the maximum element.

D. Sort the array first, then pick the middle element.

Solution

1. Step 1: Understand the array shape

   The array increases then decreases, so the peak is the maximum element where nums[mid] > nums[mid+1].

2. Step 2: Use binary search comparing nums[mid] and nums[mid+1]

   If nums[mid] > nums[mid+1], move right pointer to mid; else move left pointer to mid+1.

3. Step 3: Avoid linear scan or sorting

   Linear scan is O(n), sorting changes order and is unnecessary.

4. Final Answer:

   Use binary search comparing nums[mid] and nums[mid+1], move left or right accordingly. -> Option B

5. Quick Check:

   Compare mid and mid+1 for peak in bitonic array [OK]

Hint: Compare mid and mid+1 to find peak in bitonic array [OK]

Common Mistakes:

• Using linear scan instead of binary search
• Sorting array destroys peak property
• Comparing mid and mid-1 incorrectly