Find Peak Element LeetCode Solution (Medium) (2026)

Approach Summary

If arr[mid] < arr[mid+1], a peak exists to the right. Otherwise, it exists to the left or mid is a peak.

Practice Mode

Solve it yourself before revealing the code

DSA interviews test reasoning from brute force to optimal. Think through the constraints first.

Full Solution & Approach

A peak is an element strictly greater than both neighbors, and the problem guarantees at least one exists. The insight is that if nums[mid] < nums[mid + 1], the array is strictly rising at mid, so a peak must exist somewhere to the right — you can discard the entire left half and still not miss one. If nums[mid] > nums[mid + 1], the array is falling at mid, so a peak exists at or to the left of mid. Each comparison eliminates half the range, giving O(log n). The proof relies on the boundaries: beyond the ends the values are treated as negative infinity, so any monotonic run must terminate in a peak. This is a different flavor of binary search — instead of finding a target value, you find a local extremum by tracking the slope direction.

Each step halves the search range — O(log n) time. Constant space — O(1).

Solution Code

Solution

public 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]) left = mid + 1;
        else right = mid;
    }
    return left;
}

int findPeakElement(const vector<int>& nums) {
    int left = 0, right = (int)nums.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < nums[mid + 1]) left = mid + 1;
        else right = mid;
    }
    return left;
}

def find_peak_element(nums: list[int]) -> int:
    left, right = 0, len(nums) - 1
    while left < right:
        mid = (left + right) // 2
        if nums[mid] < nums[mid + 1]:
            left = mid + 1
        else:
            right = mid
    return left

function findPeakElement(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;
  }
  return left;
}

Edge Cases to Watch

Monotonically increasing array — the peak is the last element
Monotonically decreasing array — the peak is the first element
Single element — it is a peak by definition
Multiple peaks — any valid one is accepted

Algorithmic Pattern

Master the Binary Search Pattern

View Pattern Guide →

Study the core invariant, step-by-step decision framework, and common interview traps for the Binary Search pattern.

Framework: Binary Search • Interview Prep: Tested at FAANG • Explore all Binary Search problems & invariants →

How to Recognize This Pattern

Find any peak element in O(log n)

Complexity Analysis

Time Complexity

O(log n)

Space Complexity

O(1)

Frequently Asked Questions

What is the optimal time and space complexity for Find Peak Element?

The optimal solution for Find Peak Element achieves O(log n) runtime complexity and requires O(1) auxiliary space. Each step halves the search range — O(log n) time. Constant space — O(1).

How do I identify that Find Peak Element requires the Binary Search pattern?

In technical interviews, look for key problem signals: Find any peak element in O(log n). Recognizing these invariants allows you to bypass naive brute-force exhaustive search in favor of Binary Search strategy.

What critical edge cases must be handled in Find Peak Element?

Essential edge cases to verify include: Monotonically increasing array — the peak is the last element; Monotonically decreasing array — the peak is the first element; Single element — it is a peak by definition; Multiple peaks — any valid one is accepted. Always walk through these scenarios with your interviewer before coding.

Which tech companies frequently ask Find Peak Element?

Find Peak Element is a Medium-difficulty question tagged with medium recurrence. It is actively asked in technical screening and onsite interview loops at Google, Facebook.

Find Peak Element LeetCode Solution