在本教程中，我们将看到如何在数组中找到峰值元素。

问题

给定一系列整数。
在数组中找到峰值元素。 Peak Element是数组的元素是

GREATER THAN/EQUAL对于它的邻居，也就是说 iTh索引，索引处的邻居元素 i-1& i+1必须大于等于元素 i位置。
现在

数组可以有几个峰值元素，我们需要输出其中任何一个。

解决方案

这个问题的基本方法将通过整个阵列迭代，并且在每个I元元件上检查条件 arr[i-1] = arr[i+1]。

• 对于具有相同数量的数组，每个元素都将是峰值元素。
• 对于角元素，条件略微调整，因为它们只有一个邻居，即，对于极端左元素，我们只需检查 arr[i+1] <= arr[i]。
  对于极端正确的元素，我们只需检查 arr[i-1] <= arr[i]。

这种方法的最严重的复杂性是 O(n)。

有效的方法：

我们可以使用鸿沟和征服方法，该方法使用类似于二进制搜索的算法，其中使用中间元素检查条件，并且根据结果我们在初始阵列的一半中搜索我们的答案。
随着元素的数量在每个呼叫中获得一半，这将具有o的最严重的时间复杂性(log(n))。

算法：我们将数组的中间元素与其邻居进行比较，如果它大于或者等于其邻居。
如果中间元素大于或者等于其邻居，我们会返回它。
如果元素小于其左邻居，则确保峰值元素位于左侧。

为什么？

考虑一个数组， int[] arr = {a1, a2, a3, a4, a5, a6, a7};左邻居出现2例 (a3)比中部元素大 (a4)例如： a3 > a4：案例1：如果左邻居 (a3)是角落，那么这是我们的峰值元素。
案例-2：如果左元素不是角元素。
再次出现2个可能性，即，

• 如果 a2 > a3然后，这成为我们上面讨论的相同递归子问题，其结果最终将递归地计算。
• 如果 a2 < a3，然后再次 a3是我们的峰值元素，因为， a3 > a2& a3 > a4， 例如： a3大于或者等于其邻居。

当右邻居(A5)大于中部元素时，遵循相同的过程。

package org.igi.theitroad;
 
import java.util.Scanner;
 
public class PeakElement {
 
	public static void main(String[] args) {
 
		Scanner scn = new Scanner(System.in);
		int[] arr = new int[scn.nextInt()];
 
		for (int i = 0; i < arr.length; i++) {
			arr[i] = scn.nextInt();
		}
 
		int peakIndex = solve(0, arr.length - 1, arr);
		
		System.out.print("arr[]: {");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(" "+arr[i]);
		}
		
		System.out.println(" }");
		System.out.println("Peak element is : " + arr[peakIndex] +
                                   " found at index " + peakIndex);
 
	}
 
	public static int solve(int start, int end, int[] arr) {
		
		//finding mid for dividing the array into two parts
		int mid = (start + end)/2;
 
		//if the mid element is not the corner element and it is greater 
                //than or equal to its neighbours
		if ((mid > 0 && mid < arr.length - 1) && (arr[mid] >= 
                     arr[mid + 1] && arr[mid] >= arr[mid - 1])) {
			return mid;
		}
 
		//if the mid element is left corner element and it is greater  
                //than or equal to its right neighbour.
 
		else if (mid == 0 && mid!= arr.length-1 && arr[mid] >= 
                         arr[mid + 1])
        {
			return mid;
		}
 
		//if the mid element is right corner element and it is greater 
                //than or equalto its left neighbour.
 
		else if (mid == arr.length - 1 && mid!= 0 && 
                         arr[mid - 1] <= arr[mid]) 
        {
			return mid;
		}
 
		//if mid element is smaller than its left neighbour, 
                //then peak element will be in left side for sure.
 
		else if (mid != 0 && arr[mid - 1] > arr[mid]) 
        {
			return solve(start, mid - 1, arr);
		} 
        else 
        {
			if(mid + 1 <= arr.length-1)
            {
			   return solve(mid + 1, end, arr);
            }
		}
		//in case the array has only one element then than is the 
                //peak element
		return 0;
	}
 
}

运行上面的程序时，我们将得到以下输出。

4 10 20 40 15
arr[]: { 10 20 40 15 }
Peak element is : 40 found at index 2