Find Peak Element - Practice Coding Problems

Find Peak Element - Problem

Imagine you're hiking through a mountain range represented by an array of integers. A peak element is like a mountain summit - it's strictly higher than both its neighboring peaks. Your mission? Find any summit and return its position!

Given a 0-indexed integer array nums, find a peak element and return its index. If multiple peaks exist, you can return any of them. The array boundaries are considered to have value -∞, so elements at the edges only need to be greater than their single neighbor.

The Challenge: You must solve this in O(log n) time - no linear scanning allowed!

Example: In array [1,2,3,1], element 3 at index 2 is a peak because 3 > 2 and 3 > 1.

Input & Output

example_1.py — Basic Peak

$ Input: nums = [1,2,3,1]

› Output: 2

💡 Note: Element 3 at index 2 is a peak because 3 > 2 and 3 > 1. This is the only peak in the array.

example_2.py — Multiple Peaks

$ Input: nums = [1,2,1,3,5,6,4]

› Output: 5

💡 Note: The array has peaks at indices 1 (value 2) and 5 (value 6). The algorithm can return either one, but typically returns 5 using binary search.

example_3.py — Single Element

$ Input: nums = [1]

› Output: 0

💡 Note: A single element is always considered a peak since it has no neighbors to compare with.

Constraints

1 ≤ nums.length ≤ 1000
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
nums[i] != nums[i + 1] for all valid i
Follow up: Could you implement a solution with O(log n) time complexity?

Visualization

Tap to expand

Understanding the Visualization

Survey the Range

Start by looking at the middle of your mountain range

Follow the Slope

If the terrain is going uphill to your right, fly that direction - there must be a peak ahead

Eliminate Areas

Each decision eliminates half the mountain range from consideration

Converge on Peak

Continue until you find a summit that's higher than both sides

Key Takeaway

🎯 Key Insight: A peak always exists, and by following slope directions we can eliminate half the search space each time, achieving O(log n) efficiency!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses binary search to achieve O(log n) time complexity. The key insight is following the slope direction: if we're on an upward slope (nums[mid] < nums[mid+1]), a peak must exist to the right. If on a downward slope, a peak exists to the left. This eliminates half the search space each iteration until we converge on a peak.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use binary search by following the slope direction to eliminate half the array each time
Brute Force (Linear Search)	O(n)	O(1)	Check every element to see if it's greater than both neighbors

Binary Search (Optimal) — Algorithm Steps

Initialize left=0, right=n-1 pointers
While left < right, calculate mid = (left + right) / 2
If nums[mid] < nums[mid+1], peak is to the right: left = mid + 1
Otherwise, peak is to the left or at mid: right = mid
When left == right, we found the peak

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

Set left=0, right=n-1, find mid

Check slope

If nums[mid] < nums[mid+1], go right; else go left

Converge

Repeat until left==right, that's our peak

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findPeakElement(int* nums, int numsSize) {
    int left = 0, right = numsSize - 1;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        
        if (nums[mid] < nums[mid + 1]) {
            // Peak is to the right
            left = mid + 1;
        } else {
            // Peak is to the left or at mid
            right = mid;
        }
    }
    
    return left;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing - count commas to get size
    int count = 1;
    for (int i = 0; input[i]; i++) {
        if (input[i] == ',') count++;
    }
    
    int* nums = malloc(count * sizeof(int));
    char* token = strtok(input, "[],\n");
    int i = 0;
    while (token != NULL) {
        nums[i++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", findPeakElement(nums, count));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We eliminate half the search space in each iteration

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for pointers

✓ Linear Space

42.0K Views

High Frequency

~15 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler