Tags: , , ,

# Peak in array

Given an unsorted array, find a peak in array. A peak is defined as an element which is not smaller than its immediate neighbors. In an unsorted array, there can be many such peaks, referred to as local Maxima. Mathematically, ith element is called as peak following property holds true:

```A[i-1] <= A[i] >=A[i+1]
```

For first element and last elements of array, left and right neighbors respectively, are considered as negative infinity.

```A = A[n] = -infinity
```

For example, peak in following array would be 6 or 7 Can you identify the peak in this array? What would be peak in sorted array? It will be the last element of array and similarly, for reverse sorted array, first element will be peak.

## Peak  in array : Thought process

I recommend two things: First, get your pen and paper to practice this problem yourself. Second, try to come up with brute force solution as soon as possible. Why? Because it adds to your confidence, when you have some solution already in hand.

Brute force approach to find peak in an array of integers will be to scan through it and for each element, check if greater than it’s greater than previous and next element.  If it is, return index of that element. In worst case we would end up scanning whole array (in a sorted array), so worst case complexity of brute force solution is O(N)

Obviously, this would not have been an interview question, if expectation was to solve it in O(N) complexity, anyone with basic programming knowledge can solve it. There is no way to differentiate a good candidate from an average based on this question then. However, interviewer expects you to solve it in better than O(N) complexity and that’s where problem becomes interesting.

What if we do not go linear and randomly check index m for local maxima? If it is local maxima, we are good, return the index of that element. If it is not peak and given that array is unsorted, three situations possible at that index :
1. Array is rising toward right, that means, next element is greater than current and it’s previous element. 2.  Array is falling towards right, that means, next element is less than current and it’s previous element. 3.  It’s a valley, where current element is less than both previous and next element. In first situation, maximum should be on the right side of current index, why? In second situation, peak will be in left side of current index.

If A[m] < A[m+1], A[m] cannot be peak. However, if A[m+2] is less than A[m+1] is less than A[m+1], then A[m+1] can be a peak or some subsequent element can be. In worst case it would be the last element of array if whole A[m..end] is sorted.
If A[m] < A[m-1], in that case, either A[m-1] is peak or some element preceding it can surely be. In worst case, first element will be the peak.

### Algorithm to find peak in array

Now question is how to select m? We want to minimize the worst case number of elements to check after splitting, which is possible by splitting the array in middle. Take mid as the starting point, this is classic case of divide and conquer  approach as we will discard half of the array based on certain condition.

1. Find mid = low + (high-low)/2
2. If A[mid-1] <= A[mid] =>A[mid+1], then return mid
3. If A[mid-1] > A[mid], high = mid-1
4. If A[mid+1] > A[mid], low = mid+1
5. Repeat step 1 to 4 till there are more than one element in array. Else return that last element.

Let’s take an example and see if this algorithm works. We have given array a as below

## Find mid and see if mid is peak we are looking for, in this case it is not as A[mid] is less than A[mid+1].We will discard left subarray and look for peak in right subarray starting from mid+1. New low and high are shown, we find new mid. Is new mid, local maxima? No, as it is less than previous and next element, it is valley. We will discard right subarray and look for peak in left subarray. Now, there is only one element, hence it should be peak in array. ## Peak in array : Implementation

```package com.company;

/**
* Created by sangar on 25.3.18.
*/
public class BinarySearcchAlgorithm {

public  static int findPeak(int[] a){
int low = 0;
int high = a.length-1;

while (low<high){
int mid = low + (high-low)/2;
if(mid == low ) return a[low] > a[high] ? low:high;

//If mid is local maxima, return it.
if(a[mid-1] <= a[mid]
&& a[mid] >= a[mid+1]) return mid;
else if(a[mid-1] > a[mid]) high = mid-1;
else low = mid+1;
}
return low;
}

public static void main(String[] args) {
int[] input = {1,2,6,5,3,7,4};

int index = findPeak(input);
System.out.print("Peak found at : " + index);
}
}
```

Always remember to check for array with two elements, that will catch almost all bugs regarding boundary overflow. Also, notice that since we are accessing mid+1 and mid-1 indices of array, make sure that these indices are within bounds of array. These two things are very important for a solution to be correct and acceptable in interview. Also, to understand more about binary search algorithm and how it works, please refer to Binary search algorithm

Complexity of divide and conquer algorithm to find peak in unsorted array is O(log n). Recurrence relation for this would be T(n) = T(n/2) + c

Please share if there is something wrong or missing. If you want to contribute to website and help others to learn, please reach out to us on communications@algorithmsandme.com