Given an array, find an element before which all elements are smaller than it, and after which all are greater than it. Return index of the element if there is such an element, otherwise return -1.

**Examples:**

Input: arr[] = {5, 1, 4, 3, 6, 8, 10, 7, 9}; Output: Index of element is 4 All elements on left of arr[4] are smaller than it and all elements on right are greater. Input: arr[] = {5, 1, 4, 4}; Output: Index of element is -1

Expected time complexity is O(n).

A **Simple Solution **is to consider every element one by one. For every element, compare it with all elements on left and all elements on right. Time complexity of this solution is O(n^{2}).

An **Efficient Solution** can solve this problem in O(n) time using O(n) extra space. Below is detailed solution.

1) Create two arrays leftMax[] and rightMin[].

2) Traverse input array from left to right and fill leftMax[] such that leftMax[i] contains maximum element from 0 to i-1 in input array.

3) Traverse input array from right to left and fill rightMin[] such that rightMin[i] contains minimum element from to n-1 to i+1 in input array.

4) Traverse input array. For every element arr[i], check if arr[i] is greater than leftMax[i] and smaller than rightMin[i]. If yes, return i.

**Further Optimization** to above approach is to use only one extra array and traverse input array only twice. First traversal is same as above and fills leftMax[]. Next traversal traverses from right and keeps track of minimum. The second traversal also finds the required element.

Below is the implementation of above approach.

## C/C++

`// C++ program to find the element which is greater than ` `// all left elements and smaller than all right elements. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `int` `findElement(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// leftMax[i] stores maximum of arr[0..i-1] ` ` ` `int` `leftMax[n]; ` ` ` `leftMax[0] = INT_MIN; ` ` ` ` ` `// Fill leftMax[]1..n-1] ` ` ` `for` `(` `int` `i = 1; i < n; i++) ` ` ` `leftMax[i] = max(leftMax[i-1], arr[i-1]); ` ` ` ` ` `// Initialize minimum from right ` ` ` `int` `rightMin = INT_MAX; ` ` ` ` ` `// Traverse array from right ` ` ` `for` `(` `int` `i=n-1; i>=0; i--) ` ` ` `{ ` ` ` `// Check if we found a required element ` ` ` `if` `(leftMax[i] < arr[i] && rightMin > arr[i]) ` ` ` `return` `i; ` ` ` ` ` `// Update right minimum ` ` ` `rightMin = min(rightMin, arr[i]); ` ` ` `} ` ` ` ` ` `// If there was no element matching criteria ` ` ` `return` `-1; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `arr[] = {5, 1, 4, 3, 6, 8, 10, 7, 9}; ` ` ` `int` `n = ` `sizeof` `arr / ` `sizeof` `arr[0]; ` ` ` `cout << ` `"Index of the element is "` `<< findElement(arr, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## C#

`// C# program to find the element which is greater than ` `// all left elements and smaller than all right elements. ` `using` `System; ` ` ` `class` `GFG ` `{ ` `static` `int` `findElement(` `int` `[] arr, ` `int` `n) ` `{ ` ` ` `// leftMax[i] stores maximum of arr[0..i-1] ` ` ` `int` `[] leftMax = ` `new` `int` `[n]; ` ` ` `leftMax[0] = ` `int` `.MinValue; ` ` ` ` ` `// Fill leftMax[]1..n-1] ` ` ` `for` `(` `int` `i = 1; i < n; i++) ` ` ` `leftMax[i] = Math.Max(leftMax[i - 1], arr[i - 1]); ` ` ` ` ` `// Initialize minimum from right ` ` ` `int` `rightMin = ` `int` `.MaxValue; ` ` ` ` ` `// Traverse array from right ` ` ` `for` `(` `int` `i=n-1; i>=0; i--) ` ` ` `{ ` ` ` `// Check if we found a required element ` ` ` `if` `(leftMax[i] < arr[i] && rightMin > arr[i]) ` ` ` `return` `i; ` ` ` ` ` `// Update right minimum ` ` ` `rightMin = Math.Min(rightMin, arr[i]); ` ` ` `} ` ` ` ` ` `// If there was no element matching criteria ` ` ` `return` `-1; ` `} ` ` ` `// Driver program ` `public` `static` `void` `Main() ` `{ ` ` ` `int` `[] arr = {5, 1, 4, 3, 6, 8, 10, 7, 9}; ` ` ` `int` `n = arr.Length; ` ` ` `Console.Write( ` `"Index of the element is "` `+ findElement(arr, n)); ` `} ` `} ` ` ` `// This code is contributed ` `// by Akanksha Rai(Abby_akku) ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to find the element ` `// which is greater than all left ` `// elements and smaller than all ` `// right elements. ` ` ` `function` `findElement(` `$arr` `, ` `$n` `) ` `{ ` ` ` `// leftMax[i] stores maximum ` ` ` `// of arr[0..i-1] ` ` ` `$leftMax` `= ` `array` `(0); ` ` ` `$leftMax` `[0] = PHP_INT_MIN; ` ` ` ` ` `// Fill leftMax[]1..n-1] ` ` ` `for` `(` `$i` `= 1; ` `$i` `< ` `$n` `; ` `$i` `++) ` ` ` `$leftMax` `[` `$i` `] = max(` `$leftMax` `[` `$i` `- 1], ` ` ` `$arr` `[` `$i` `- 1]); ` ` ` ` ` `// Initialize minimum from right ` ` ` `$rightMin` `= PHP_INT_MAX; ` ` ` ` ` `// Traverse array from right ` ` ` `for` `(` `$i` `= ` `$n` `- 1; ` `$i` `>= 0; ` `$i` `--) ` ` ` `{ ` ` ` `// Check if we found a required ` ` ` `// element ` ` ` `if` `(` `$leftMax` `[` `$i` `] < ` `$arr` `[` `$i` `] && ` ` ` `$rightMin` `> ` `$arr` `[` `$i` `]) ` ` ` `return` `$i` `; ` ` ` ` ` `// Update right minimum ` ` ` `$rightMin` `= min(` `$rightMin` `, ` `$arr` `[` `$i` `]); ` ` ` `} ` ` ` ` ` `// If there was no element ` ` ` `// matching criteria ` ` ` `return` `-1; ` `} ` ` ` `// Driver Code ` `$arr` `= ` `array` `(5, 1, 4, 3, 6, 8, 10, 7, 9); ` `$n` `= ` `count` `(` `$arr` `); ` `echo` `"Index of the element is "` `, ` ` ` `findElement(` `$arr` `, ` `$n` `); ` ` ` `// This code is contributed ` `// by Sach_Code ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

Index of the element is 4

**Time Complexity:** O(n)

**Auxiliary Space:** O(n)

Thanks to Gaurav Ahirwar for suggesting above solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

## Recommended Posts:

- Find next Smaller of next Greater in an array
- Rearrange array such that even index elements are smaller and odd index elements are greater
- Maximum difference between two elements such that larger element appears after the smaller number
- Find closest smaller value for every element in array
- Sum of elements in an array with frequencies greater than or equal to that element
- Adding elements of an array until every element becomes greater than or equal to k
- Find maximum difference between nearest left and right smaller elements
- Find all elements in array which have at-least two greater elements
- Find closest greater value for every element in array
- Delete array elements which are smaller than next or become smaller
- Find element in a sorted array whose frequency is greater than or equal to n/2.
- Longest Subarray with first element greater than or equal to Last element
- Next Smaller Element
- Find the element having different frequency than other array elements
- Find an array element such that all elements are divisible by it