Finding a Peak Element in an Array in C++

Elements that are larger than the elements next to them are called peak elements in an array. They can be very important in many different applications, such as dataset identification or algorithm optimization. In this article, we will learn how to find a peak element in an array in C++.

What are Peak Elements?

An element in an array that is greater than or equal to its neighbours is called a Peak element. According to this definition, an array may have more than one peak element, and it may be useful to locate any one of them depending on the situation. Depending on these parameters, the array may be sorted or unsorted, and different methods may be used to identify peak elements.

Finding Peak Elements in an Unsorted Array:-

Since finding peak elements in an unsorted array is a more general situation with intriguing issues, we will begin by talking about it.

Naive Approach:

Analyzing each element's neighbours while iterating over the full array is a primitive method of locating peak elements in an unsorted array. An element is considered to be peak if it is larger than its neighbours.

Program:

Let's take a C++ program to find a peak element in an array:

#include <iostream>
#include <vector>
int findPeakElement(const std::vector<int>& arr) {
 int n = arr.size();
 for (int i = 0; i < n; ++i) {
 if ((i == 0 || arr[i] >= arr[i - 1]) && (i == n - 1 || arr[i] >= arr[i + 1])) {
 return arr[i];
 }
 }
 return -1; // No peak element found
}
int main() {
 std::vector<int> arr = {1, 3, 20, 4, 1, 0};
 int peak = findPeakElement(arr);
 if (peak != -1) {
 std::cout << "A peak element is: " << peak << std::endl;
 } else {
 std::cout << "No peak element found in the array." << std::endl;
 }
 return 0;
}

Output:

Finding a Peak Element in an Array in C++

This simple method verifies each entry in the array, which results in an O(n) time complexity.

Using Binary Search Method:-

Binary search is a more effective method. The time complexity of this method is O(log n). There are some following steps:

Arr[mid], the array's middle element, is where you should start.
Examine it in relation to arr[mid - 1] and arr[mid + 1], its neighbours.
Arr[mid] is a peak element and can be returned if it is greater than both of its neighbours.
Proceed to the left and repeat the procedure in the left subarray if arr[mid - 1] is larger than arr[mid].
Go right and repeat the procedure in the right subarray if arr[mid + 1] is greater than arr[mid].
By dividing the array in half at each stage in this binary search method, we are able to eliminate half of the elements in each iteration and produce an algorithm that is more efficient.

Program:

Let's take a C++ program to find a peak element in an array using binary search method:

#include <iostream>
#include <vector>

int findPeakElement(const std::vector<int>& arr, int low, int high) {
 if (low == high) {
 return arr[low];
 }

 int mid = (low + high) / 2;

 if (arr[mid] > arr[mid + 1]) {
 return findPeakElement(arr, low, mid);
 } else {
 return findPeakElement(arr, mid + 1, high);
 }
}

int main() {
 std::vector<int> arr = {1, 3, 20, 4, 1, 0};
 int peak = findPeakElement(arr, 0, arr.size() - 1);
 if (peak != -1) {
 std::cout << "A peak element is: " << peak << std::endl;
 } else {
 std::cout << "No peak element found in the array." << std::endl;
 }
 return 0;
}

Output:

Finding Maximum Elements in a Sorted Array:-

Finding the peak elements is not too difficult if the array is sorted either ascending or descending.

A peak in an array sorted in ascending order:-

A peak element is always the last element in an array that has been sorted in ascending order.

Here's a basic C++ implementation of that:

#include <iostream>
#include <vector>

int findPeakElement(const std::vector<int>& arr) {
 return arr.back();
}

int main() {
 std::vector<int> arr = {1, 3, 6, 9, 12, 15};
 int peak = findPeakElement(arr);
 std::cout << "A peak element is: " << peak << std::endl;
 return 0;
}

Output:

Since it is certain to be a peak in this instance, we return the array's final element.

A Peak array sorted in a descending order:-

The peak is the first member in an array that has been sorted in descending order.

Here's where to look for it:

#include <iostream>
#include <vector>

int findPeakElement(const std::vector<int>& arr) {
 return arr[0];
}

int main() {
 std::vector<int> arr = {15, 12, 9, 6, 3, 1};
 int peak = findPeakElement(arr);
 std::cout << "A peak element is: " << peak << std::endl;
 return 0;
}

Output:

Once more, it is simple to locate the peak element in a sorted array; depending on the sorting order, wer just need to take into account the first or final element.

Conclusion:

An intriguing topic with a wide range of applications is finding the peak element in an array. Identifying the peak elements in an array of depends on whether it is sorted or not. Binary search can be used to find an efficient solution in an unsorted array, although it is simpler in sorted arrays.

Finding peak elements efficiently can be crucial for improving algorithms and finding solutions to issues in a variety of fields, including computer science and data analysis. Peak elements in C++ can be efficiently identified by grasping the ideas and techniques discussed in this article, regardless of whether you are working with sorted or unsorted arrays.

Next Topicforward_list::splice_after() in C++

← prev next →