Find Peak Element

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

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

✓ Two Pass Hash

⏱️ Time: N/A Space: N/A

Binary Search

⏱️ Time: O(log n) Space: O(1)

Apply binary search principle by checking the middle element and its neighbor. If ascending slope, peak must be on the right; if descending slope, peak must be on the left.

Linear Search

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

Iterate through the array and check each element against its neighbors. Handle edge cases for first and last elements by treating out-of-bounds as negative infinity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashSet;

int hash(int value) {
    return (value % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

HashSet* createHashSet() {
    HashSet* set = calloc(1, sizeof(HashSet));
    return set;
}

void insertHashSet(HashSet* set, int value) {
    int index = hash(value);
    HashNode* node = set->buckets[index];
    
    while (node) {
        if (node->value == value) return;
        node = node->next;
    }
    
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->value = value;
    newNode->next = set->buckets[index];
    set->buckets[index] = newNode;
}

int containsHashSet(HashSet* set, int value) {
    int index = hash(value);
    HashNode* node = set->buckets[index];
    
    while (node) {
        if (node->value == value) return 1;
        node = node->next;
    }
    return 0;
}

typedef struct {
    int* data;
    int size;
    int capacity;
} IntList;

IntList* createList() {
    IntList* list = malloc(sizeof(IntList));
    list->capacity = 10;
    list->data = malloc(list->capacity * sizeof(int));
    list->size = 0;
    return list;
}

void addToList(IntList* list, int value) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, list->capacity * sizeof(int));
    }
    list->data[list->size++] = value;
}

void collectFromHashSet(HashSet* set, IntList* list) {
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = set->buckets[i];
        while (node) {
            addToList(list, node->value);
            node = node->next;
        }
    }
}

int* parseArray(char* str, int* size) {
    int* arr = malloc(1000 * sizeof(int));
    *size = 0;
    
    char* ptr = str;
    while (*ptr) {
        if (*ptr == '-' || isdigit(*ptr)) {
            char* endptr;
            int num = strtol(ptr, &endptr, 10);
            if (endptr != ptr) {
                arr[(*size)++] = num;
                ptr = endptr;
            } else {
                ptr++;
            }
        } else {
            ptr++;
        }
    }
    return arr;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int size1, size2;
    int* nums1 = parseArray(line1, &size1);
    int* nums2 = parseArray(line2, &size2);
    
    HashSet* set1 = createHashSet();
    HashSet* set2 = createHashSet();
    
    for (int i = 0; i < size1; i++) insertHashSet(set1, nums1[i]);
    for (int i = 0; i < size2; i++) insertHashSet(set2, nums2[i]);
    
    IntList* temp1 = createList();
    IntList* temp2 = createList();
    collectFromHashSet(set1, temp1);
    collectFromHashSet(set2, temp2);
    
    IntList* diff1 = createList();
    IntList* diff2 = createList();
    
    for (int i = 0; i < temp1->size; i++) {
        if (!containsHashSet(set2, temp1->data[i])) {
            addToList(diff1, temp1->data[i]);
        }
    }
    
    for (int i = 0; i < temp2->size; i++) {
        if (!containsHashSet(set1, temp2->data[i])) {
            addToList(diff2, temp2->data[i]);
        }
    }
    
    printf("[[");
    for (int i = 0; i < diff1->size; i++) {
        if (i > 0) printf(",");
        printf("%d", diff1->data[i]);
    }
    printf("],[");
    for (int i = 0; i < diff2->size; i++) {
        if (i > 0) printf(",");
        printf("%d", diff2->data[i]);
    }
    printf("]]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ 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