Find Peak Element in an Array Using Binary Search

Introduction

The Find Peak Element in an Array problem is a very popular DSA interview question that looks simple but tests your ability to apply binary search in a non-obvious way.

In simple words, this problem asks you to find an element that is greater than its neighbors.

This article explains the problem in simple, human-friendly language, with real-life meaning, clear logic, and a binary search approach that interviewers expect.

Real-World Meaning of Peak Element

Imagine you are driving on a hilly road:

• The road goes up

• Then at some point it goes down

The highest point you cross is a peak.

In the same way, a peak element in an array is a number that is bigger than the numbers next to it.

What is a Peak Element?

An element is called a peak element if:

• It is greater than its left neighbor

• It is greater than its right neighbor

Important Notes

• The array does not need to be sorted

• There can be multiple peak elements

• You can return any one peak

Problem Statement

You are given an array of integers. Find the index of any peak element.

Example

Array: [1, 2, 3, 1]
Output: 2

Explanation:

• 3 is greater than 2 and 1, so it is a peak

Before vs After Understanding

Brute Force Thinking (Before)

• Check every element

• Compare with neighbors

• Time-consuming for large arrays

Binary Search Thinking (After)

• Look at middle element

• Decide which side has a peak

• Reduce search space by half

Why Binary Search Works Here

This may feel confusing at first because the array is not sorted.

Binary search works because:

• If one side is going up, a peak must exist there

• If one side is going down, a peak exists on the other side

This guarantees a peak in the chosen half.

What Interviewers Are Actually Testing

Interviewers want to see:

• Can you apply binary search creatively?

• Do you understand problem properties?

• Can you think beyond sorted arrays?

This problem checks problem-solving depth, not memorization.

Key Idea (Very Simple)

• Compare middle element with its right neighbor

• If middle is smaller, peak lies on the right

• If middle is bigger, peak lies on the left or is the middle itself

Step-by-Step Logic

1. Set low = 0, high = n - 1

2. Find mid

3. Compare arr[mid] with arr[mid + 1]

4. If arr[mid] < arr[mid + 1], move right

5. Else, move left

6. Continue until low == high

That index is a peak.

Dry Run Example

Array: [1, 2, 3, 1]

low	high	mid	comparison	move
0	3	1	2 < 3	right
2	3	2	3 > 1	left

Answer index = 2

One-Line Logic Before Code

Move toward the side where values are increasing.

Code Implementation (C++)

int findPeakElement(vector<int>& nums) {
    int low = 0, high = nums.size() - 1;

    while (low < high) {
        int mid = low + (high - low) / 2;
        if (nums[mid] < nums[mid + 1])
            low = mid + 1;
        else
            high = mid;
    }
    return low;
}

Common Beginner Mistakes

• Thinking array must be sorted

• Checking both neighbors unnecessarily

• Overcomplicating the logic

Time and Space Complexity

• Time Complexity: O(log n)

• Space Complexity: O(1)

This is much faster than brute force.

Easy Summary (Explain Like I’m 10)

If numbers go up and then go down, the highest number in between is a peak. By always moving in the direction where numbers are rising, we can quickly find a peak without checking every number.

Summary

Finding a peak element in an array using binary search is a smart application of binary search beyond sorted data. By comparing middle elements with their neighbors and reducing the search space, you can find a peak efficiently in logarithmic time. This problem is commonly asked in interviews to test logical thinking and binary search mastery.