Find Peak Element - Practice Coding Problems

Find Peak Element - Problem

A peak element is an element that is strictly greater than its neighbors.

Given a 0-indexed integer array nums, find a peak element, and return its index. If the array contains multiple peaks, return the index to any of the peaks.

You may imagine that nums[-1] = nums[n] = -∞. In other words, an element is always considered to be strictly greater than a neighbor that is outside the array.

You must write an algorithm that runs in O(log n) time.

Input & Output

Example 1 — 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 satisfies the peak condition.

Example 2 — Multiple Peaks

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

› Output: 5

💡 Note: Element 6 at index 5 is a peak because 6 > 5 and 6 > 4. Index 1 (element 2) is also a peak, but we can return any peak.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 0

💡 Note: With only one element, it's automatically 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

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,2,3,1] where we need to find peak

Process

Check each element against its neighbors

Output

Return index 2 where element 3 is peak

Key Takeaway

🎯 Key Insight: Use binary search by following slope direction - ascending slopes lead to peaks on the right, descending slopes have peaks on the left

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is that we can use binary search by following slope direction. If we're at middle element and it's smaller than the next element (ascending slope), the peak must be on the right side. Best approach is binary search with Time: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search	O(n)	O(1)	Check every element to see if it's greater than its neighbors
Binary Search	O(log n)	O(1)	Use binary search by following the slope direction to find peak

Linear Search — Algorithm Steps

Iterate through each element
Check if current element is greater than both neighbors
Return index if peak found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin checking from first element

Compare

Check if current element is greater than neighbors

Found

Return index when peak is found

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    // Handle single element
    if (numsSize == 1) {
        return 0;
    }
    
    // Check first element
    if (nums[0] > nums[1]) {
        return 0;
    }
    
    // Check last element
    if (nums[numsSize-1] > nums[numsSize-2]) {
        return numsSize-1;
    }
    
    // Check middle elements
    for (int i = 1; i < numsSize-1; i++) {
        if (nums[i] > nums[i-1] && nums[i] > nums[i+1]) {
            return i;
        }
    }
    
    return -1; // Should never reach here
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array checking each element

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

62.0K Views

High Frequency

~15 min Avg. Time

1.8K 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

Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler