Find local minima in an array | Data Structures and Algorithm

Given an array of unique integers whose first two numbers are decreasing and last two numbers are increasing, find a number in the array which is local minima. A number in the array is called local minima if it is smaller than both its left and right numbers.
For example in the array 9,7,2,8,5,6,3,4
2 is a local minima as it is smaller than its left and right number 7 and 8. Similarly 5 is another local minima as it is between 8 and 6, both larger than 5.
You need to find any one of the local minima.
Prove there must be a local minima.

First we will do it by negation. If first two numbers are decreasing, and there is no local minima, that means 3rd number is less than 2nd number. otherwise 2nd number would have been local minima. Following the same logic 4th number will have to be less than 3rd number and so on and so forth. So the numbers in the array will have to be in decreasing order. Which violates the constraint of last two numbers being in increasing order. This proves by negation that there need to be a local minima.

We can prove this in some other way also. Suppose we represent the array as a 2-D graph where the index of the numbers in the array represents the x-coordinate. and the number represents the y-coordinate. Now for the first two numbers, derivative will be negative, and for last two numbers derivative will be positive. So at some point the derivative line will have to cross the x axis. As the array contains only unique elements there cannot be a derivative point on the x axis. Because that will mean that two consecutive index having same number. So for any intersection of x axis by the derivative line will be a local minima.

private static int findLocalMinima(int[] arr)
 {
  return findLocalMinima(arr, 0, arr.length);
 }

 private static int findLocalMinima(int[] arr, int start, int end)
 {
  int mid = (start + end) / 2;
  if (mid - 2 < 0 && mid + 1 >= arr.length)
   return -1;
  if (arr[mid - 2] > arr[mid - 1] && arr[mid - 1] < arr[mid])
   return arr[mid - 1];
  if (arr[mid - 1] > arr[mid - 2])
   return findLocalMinima(arr, start, mid);
  else
   return findLocalMinima(arr, mid, end);
 }

Similar post: Arrays : Finding peaks in an array
http://www.geeksforgeeks.org/find-a-peak-in-a-given-array/
Given an array of integers. Find a peak element in it. An array element is peak if it is NOT smaller than its neighbors. For corner elements, we need to consider only one neighbor. 
We can use Divide and Conquer to find a peak in O(Logn) time. The idea is Binary Search based, we compare middle element with its neighbors. If middle element is greater than both of its neighbors, then we return it. If the middle element is smaller than the its left neighbor, then there is always a peak in left half (Why? take few examples). If the middle element is smaller than the its right neighbor, then there is always a peak in right half (due to same reason as left half). 

int findPeakUtil(int arr[], int low, int high, int n)

{

    // Fin index of middle element

    int mid = low + (high - low)/2;  /* (low + high)/2 */

    // Compare middle element with its neighbours (if neighbours exist)

    if ((mid == 0 || arr[mid-1] <= arr[mid]) &&

            (mid == n-1 || arr[mid+1] <= arr[mid]))

        return mid;

    // If middle element is not peak and its left neighbor is greater than it

    // then left half must have a peak element

    else if (mid > 0 && arr[mid-1] > arr[mid])

        return findPeakUtil(arr, low, (mid -1), n);

    // If middle element is not peak and its right neighbor is greater than it

    // then right half must have a peak element

    else return findPeakUtil(arr, (mid + 1), high, n);

}

http://www.geeksforgeeks.org/find-local-minima-array/

Given an array arr[0 .. n-1] of distinct integers, the task is to find a local minima in it. We say that an element arr[x] is a local minimum if it is less than or equal to both its neighbors.

• For corner elements, we need to consider only one neighbor for comparison.
• There can be more than one local minima in an array, we need to find any one of them.

An efficient solution is based on Binary Search. We compare middle element with its neighbors. If middle element is not greater than any of its neighbors, then we return it. If the middle element is greater than its left neighbor, then there is always a local minima in left half (Why? take few examples). If the middle element is greater than its right neighbor, then there is always a local minima in right half (due to same reason as left half).

    // A binary search based function that returns

    // index of a local minima.

    public static int localMinUtil(int[] arr, int low, int high, int n)

    {

         

        // Find index of middle element

        int mid = low + (high-low)/2;

         

         // Compare middle element with its neighbours

        // (if neighbours exist)

        if(mid == 0 || arr[mid-1] > arr[mid] && mid == n-1 || arr[mid] < arr[mid+1])

                return mid;

         

        // If middle element is not minima and its left

        // neighbour is smaller than it, then left half

        // must have a local minima.

        else if(mid > 0 && arr[mid-1] < arr[mid])

                return localMinUtil(arr, low, mid-1, n);

         

        // If middle element is not minima and its right

        // neighbour is smaller than it, then right half

        // must have a local minima.

        return localMinUtil(arr, mid+1, high, n);

    }

     

    // A wrapper over recursive function localMinUtil()

    public static int localMin(int[] arr, int n)

    {

        return localMinUtil(arr, 0, n-1, n);

    }

Read full article from Find local minima in an array | Data Structures and Algorithm