Find Peak Element Using Binary Search in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find Peak Element Output

What is the output index of the peak element for the given array using the binary search approach?

DSA C++

int findPeakElement(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

vector<int> nums = {1, 3, 20, 4, 1, 0};
int peakIndex = findPeakElement(nums);
cout << peakIndex;

A 3

B 1

C 2

D 0

💡 Hint

Check where the element is greater than its next neighbor.

The binary search narrows down to the peak element by comparing mid element with its next element. Since 20 at index 2 is greater than 4 at index 3, the peak is at index 2.

❓ Predict Output

intermediate

Find Peak Element Output with Multiple Peaks

What is the output index of the peak element for the array with multiple peaks using the binary search approach?

DSA C++

int findPeakElement(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

vector<int> nums = {1, 2, 3, 1, 2, 1};
int peakIndex = findPeakElement(nums);
cout << peakIndex;

A 2

B 4

C 1

D 3

💡 Hint

Binary search finds any peak, not necessarily the first or last.

The binary search finds index 2 where nums[2] = 3 is a peak (greater than neighbors 2 and 1).

🧠 Conceptual

advanced

Why Binary Search Works for Peak Element?

Why does the binary search approach always find a peak element in an unsorted array?

A Because if the middle element is smaller than the next, a peak must exist on the right side; otherwise, on the left side.

B Because the array is sorted, so the middle element is always a peak.

C Because the algorithm checks all elements one by one to find the peak.

D Because the peak element is always at the start or end of the array.

💡 Hint

Think about the direction where the array is increasing or decreasing.

If nums[mid] < nums[mid+1], a peak must exist on the right side; else, on the left side. This guarantees finding a peak.

🔧 Debug

advanced

Identify the Bug in Peak Element Code

What error will this code cause when finding a peak element?

DSA C++

int findPeakElement(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

A Compiles but returns -1 always

B Runtime error due to out-of-bounds access at nums[mid + 1]

C Returns wrong peak index because of incorrect mid calculation

D Infinite loop because left and right pointers never converge

💡 Hint

Check the condition when mid is at the last index.

When mid is at the last index, nums[mid + 1] accesses out-of-bounds causing runtime error.

🚀 Application

expert

Find Peak Element in Circular Array

Given a circular array where the end connects to the start, which approach correctly finds a peak element?

A Sort the array first then pick the middle element as peak

B Linear scan from start to end to find any element greater than neighbors

C Use binary search but ignore wrap-around and compare only nums[mid] and nums[mid + 1]

D Use the standard binary search comparing nums[mid] and nums[(mid + 1) % n] to handle wrap-around

💡 Hint

Think about how to handle the circular nature in index calculation.

Using modulo operator handles wrap-around, allowing binary search to find peak in circular array.