Peak Element Finder - Problem

A peak element in an array is an element that is greater than both of its neighbors. Given an integer array nums, find all peak elements and return their indices.

For edge elements (first and last elements), they are considered peaks if they are greater than their single neighbor.

Special cases:

If the array has only one element, it is always a peak
The first element is a peak if it's greater than the second element
The last element is a peak if it's greater than the second-to-last element

Input & Output

Example 1 — Multiple Peaks

$ Input: nums = [5,2,8,3,7,1]

› Output: [0,2,4]

💡 Note: Index 0: 5 > 2 (first element peak), Index 2: 8 > 2 and 8 > 3 (middle peak), Index 4: 7 > 3 and 7 > 1 (middle peak)

Example 2 — Edge Peaks Only

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

› Output: [0,3]

💡 Note: Index 0: 4 > 1 (first element is peak), Index 3: 3 > 2 (last element is peak)

Example 3 — Single Element

$ Input: nums = [7]

› Output: [0]

💡 Note: Single element is always a peak by definition

Constraints

1 ≤ nums.length ≤ 1000
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is that each element only needs to be compared with its immediate neighbors. The optimal approach uses a single pass with smart boundary checking, examining each element's left and right neighbors when they exist. Time: O(n), Space: O(k) where k is the number of peaks.

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n) Space: O(k)

For each element in the array, explicitly check if it's greater than both neighbors, with special handling for first and last elements. This approach clearly handles all edge cases but checks every element individually.

Single Pass Optimized

⏱️ Time: O(n) Space: O(k)

Uses a single loop that handles all cases - first element, middle elements, and last element - with optimized boundary checks. This reduces code duplication while maintaining clarity.

Brute Force Comparison — Algorithm Steps

Step 1: Iterate through each element in the array
Step 2: For each element, check if it's a peak using neighbor comparison
Step 3: Handle edge cases for first and last elements separately
Step 4: Collect all peak indices and return them

Visualization

Tap to expand

Step-by-Step Walkthrough

Check First

Compare first element with next neighbor

Check Middle

Compare each middle element with both neighbors

Check Last

Compare last element with previous neighbor

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = 0;
    if (nums == NULL || numsSize == 0) {
        return NULL;
    }
    
    int* peaks = (int*)malloc(numsSize * sizeof(int));
    
    // Handle single element
    if (numsSize == 1) {
        peaks[0] = 0;
        *returnSize = 1;
        return peaks;
    }
    
    // Check first element
    if (nums[0] > nums[1]) {
        peaks[(*returnSize)++] = 0;
    }
    
    // Check middle elements
    for (int i = 1; i < numsSize - 1; i++) {
        if (nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) {
            peaks[(*returnSize)++] = i;
        }
    }
    
    // Check last element
    if (nums[numsSize - 1] > nums[numsSize - 2]) {
        peaks[(*returnSize)++] = numsSize - 1;
    }
    
    return peaks;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int num = atoi(token);
        if (num != 0 || token[0] == '0') {
            nums[numsSize++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant time comparisons

✓ Linear Growth

Space Complexity

O(k)

Storage for result array where k is number of peaks

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Peak Element Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler