# Find a partition point in array

Given an unsorted array of integers. Find an element such that all the elements to its left are smaller and to its right are greater. Print -1 if no such element exists.

Note that there can be more than one such elements. For example an array which is sorted in increasing order all elements follow the property. We need to find only one such element.

Examples :

```Input :  A[] = {4, 3, 2, 5, 8, 6, 7}
Output : 5

Input : A[] = {5, 6, 2, 8, 10, 9, 8}
Output : -1
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Simple solution takes O(n2). Idea is to pick each array element one by one and for each element we have to check it is greater than all the elements to its left side and smaller than all the elements to its right side.

Below is the implementation of above idea :

## C++

 `// Simple C++ program to find a partition point in ` `// an array ` `#include ` `using` `namespace` `std; ` ` `  `// Prints an element such than all elements on left ` `// are smaller and all elements on right are greater. ` `int` `FindElement(``int` `A[], ``int` `n) ` `{ ` `    ``// traverse array elements ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``// If we found that such number ` `        ``int` `flag = 0; ` ` `  `        ``// check All the elements on its left are smaller ` `        ``for` `(``int` `j = 0; j < i; j++) ` `            ``if` `(A[j] >= A[i]) { ` `                ``flag = 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// check All the elements on its right are Greater ` `        ``for` `(``int` `j = i + 1; j < n; j++) ` `            ``if` `(A[j] <= A[i]) { ` `                ``flag = 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// If flag == 0 indicates we found that number ` `        ``if` `(flag == 0) ` `            ``return` `A[i]; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `A[] = { 4, 3, 2, 5, 8, 6, 7 }; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A); ` `    ``cout << FindElement(A, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Simple Java program to find  ` `// a partition point in an array ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Prints an element such than all elements  ` `    ``// on left are smaller and all elements on  ` `    ``// right are greater. ` `    ``static` `int` `FindElement(``int``[] A, ``int` `n) ` `    ``{ ` `        ``// traverse array elements ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `             `  `            ``// If we found that such number ` `            ``int` `flag = ``0``; ` ` `  `            ``// check All the elements on  ` `            ``// its left are smaller ` `            ``for` `(``int` `j = ``0``; j < i; j++) ` `                ``if` `(A[j] >= A[i]) { ` `                    ``flag = ``1``; ` `                    ``break``; ` `                ``} ` ` `  `            ``// check All the elements on  ` `            ``// its right are Greater ` `            ``for` `(``int` `j = i + ``1``; j < n; j++) ` `                ``if` `(A[j] <= A[i]) { ` `                    ``flag = ``1``; ` `                    ``break``; ` `                ``} ` ` `  `            ``// If flag == 0 indicates we ` `            ``// found that number ` `            ``if` `(flag == ``0``) ` `                ``return` `A[i]; ` `        ``} ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] A = {``4``, ``3``, ``2``, ``5``, ``8``, ``6``, ``7``}; ` `        ``int` `n = A.length; ` `        ``System.out.println(FindElement(A, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m  `

## Python3

 `# Simple python 3 program to find a  ` `# partition point in an array ` ` `  `# Prints an element such than all  ` `# elements on left are smaller and  ` `# all elements on right are greater. ` `def` `FindElement(A, n): ` `     `  `    ``# traverse array elements ` `    ``for` `i ``in` `range``(``0``, n, ``1``): ` `         `  `        ``# If we found that such number ` `        ``flag ``=` `0` ` `  `        ``# check All the elements on its ` `        ``# left are smaller ` `        ``for` `j ``in` `range``(``0``, i, ``1``): ` `            ``if` `(A[j] >``=` `A[i]): ` `                ``flag ``=` `1` `                ``break` ` `  `        ``# check All the elements on its  ` `        ``# right are Greater ` `        ``for` `j ``in` `range``(i ``+` `1``, n, ``1``): ` `            ``if` `(A[j] <``=` `A[i]): ` `                ``flag ``=` `1` `                ``break` ` `  `        ``# If flag == 0 indicates we found ` `        ``# that number ` `        ``if` `(flag ``=``=` `0``): ` `            ``return` `A[i] ` ` `  `    ``return` `-``1` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``A ``=` `[``4``, ``3``, ``2``, ``5``, ``8``, ``6``, ``7``] ` `    ``n ``=` `len``(A) ` `    ``print``(FindElement(A, n)) ` ` `  `# This code is contributed by ` `# Sanjit_Prasad `

## C#

 `// Simple C# program to find a ` `// partition point in an array ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Prints an element such than all ` `    ``// elements on left are smaller and all  ` `    ``// elements on right are greater. ` `    ``static` `int` `FindElement(``int``[] A, ``int` `n) ` `    ``{ ` `        ``// traverse array elements ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `             `  `            ``// If we found that such number ` `            ``int` `flag = 0; ` ` `  `            ``// check All the elements on  ` `            ``// its left are smaller ` `            ``for` `(``int` `j = 0; j < i; j++) ` `                ``if` `(A[j] >= A[i]) { ` `                    ``flag = 1; ` `                    ``break``; ` `                ``} ` ` `  `            ``// check All the elements on  ` `            ``// its right are Greater ` `            ``for` `(``int` `j = i + 1; j < n; j++) ` `                ``if` `(A[j] <= A[i]) { ` `                    ``flag = 1; ` `                    ``break``; ` `                ``} ` ` `  `            ``// If flag == 0 indicates we ` `            ``// found that number ` `            ``if` `(flag == 0) ` `                ``return` `A[i]; ` `        ``} ` `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[] A = { 4, 3, 2, 5, 8, 6, 7 }; ` `        ``int` `n = A.Length; ` `        ``Console.WriteLine(FindElement(A, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 `= ``\$A``[``\$i``]) ` `            ``{ ` `                ``\$flag` `= 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// check All the elements on its  ` `        ``// right are Greater ` `        ``for` `( ``\$j` `= ``\$i` `+ 1; ``\$j` `< ``\$n``; ``\$j``++) ` `            ``if` `(``\$A``[``\$j``] <= ``\$A``[``\$i``])  ` `            ``{ ` `                ``\$flag` `= 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// If flag == 0 indicates we found  ` `        ``// that number ` `        ``if` `(``\$flag` `== 0) ` `            ``return` `\$A``[``\$i``]; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `\$A` `= ``array``( 4, 3, 2, 5, 8, 6, 7 ); ` `\$n` `= ``count``(``\$A``); ` `echo` `FindElement(``\$A``, ``\$n``); ` ` `  `// This code is contributed by ` `// Rajput-Ji ` `?> `

Output:

```5
```

Time complexity: O(n2)

Efficient solution take O(n) time.

1. Create an auxiliary array ‘GE[]’. GE[] should store the element which is greater than A[i] and is on left side of A[i].
2. Create an another Auxliary array ‘SE[]’. SE[i] should store the element which is smaller than A[i] and is on right side of A[i].
3. Find element in array that hold condition GE[i-1] < A[i] < SE[i+1].

Below is the implementation of above idea :

## C++

 `// Simple C++ program to find ` `// a partition point in an array ` `#include ` `using` `namespace` `std; ` ` `  `// Returns an element that has all  ` `// the element to its left smaller and ` `// to its right greater ` `int` `FindElement(``int` `A[], ``int` `n) ` `{ ` `    ``// Create an array 'SE[]' that will ` `    ``// store smaller element on right side. ` `    ``int` `SE[n]; ` ` `  `    ``// Create an another array 'GE[]' that will  ` `    ``// store greatest element on left side. ` `    ``int` `GE[n]; ` ` `  `    ``// initialize first and last index of SE[], GE[] ` `    ``GE = A; ` `    ``SE[n - 1] = A[n - 1]; ` ` `  `    ``// store greatest element from left to right ` `    ``for` `(``int` `i = 1; i < n; i++) { ` `        ``if` `(GE[i - 1] < A[i]) ` `            ``GE[i] = A[i]; ` `        ``else` `            ``GE[i] = GE[i - 1]; ` `    ``} ` ` `  `    ``// store smallest element from right to left ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` `        ``if` `(A[i] < SE[i + 1]) ` `            ``SE[i] = A[i]; ` `        ``else` `            ``SE[i] = SE[i + 1]; ` `    ``} ` ` `  `    ``// Now find a number which is greater then all ` `    ``// elements at it's left and smaller the all ` `    ``// then elements to it's right ` `    ``for` `(``int` `j = 0; j < n; j++)  ` `    ``{ ` `        ``if` `((j == 0 && A[j] < SE[j + 1]) ||  ` `            ``(j == n - 1 && A[j] > GE[j - 1]) || ` `            ``(A[j] < SE[j + 1] && A[j] > GE[j - 1])) ` `            ``return` `A[j]; ` `    ``} ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = {4, 3, 2, 5, 8, 6, 7}; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A); ` `    ``cout << FindElement(A, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Simple java program to find a  ` `// partition point in an array ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns an element that has all  ` `    ``// the element to its left smaller  ` `    ``// and to its right greater ` `    ``static` `int` `FindElement(``int``[] A, ``int` `n) ` `    ``{ ` `        ``// Create an array 'SE[]' that will  ` `        ``// store smaller element on right side. ` `        ``int``[] SE = ``new` `int``[n]; ` ` `  `        ``// Create an another array 'GE[]' that  ` `        ``// will store greatest element on left side. ` `        ``int``[] GE = ``new` `int``[n]; ` ` `  `        ``// initialize first and last index of SE[], GE[] ` `        ``GE[``0``] = A[``0``]; ` `        ``SE[n - ``1``] = A[n - ``1``]; ` ` `  `        ``// store greatest element from left to right ` `        ``for` `(``int` `i = ``1``; i < n; i++)  ` `        ``{ ` `            ``if` `(GE[i - ``1``] < A[i]) ` `                ``GE[i] = A[i]; ` `            ``else` `                ``GE[i] = GE[i - ``1``]; ` `        ``} ` ` `  `        ``// store smallest element from right to left ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--)  ` `        ``{ ` `            ``if` `(A[i] < SE[i + ``1``]) ` `                ``SE[i] = A[i]; ` `            ``else` `                ``SE[i] = SE[i + ``1``]; ` `        ``} ` ` `  `        ``// Now find a number which is greater then all ` `        ``// elements at it's left and smaller the all ` `        ``// then elements to it's right ` `        ``for` `(``int` `j = ``0``; j < n; j++)  ` `        ``{ ` `            ``if` `((j == ``0` `&& A[j] < SE[j + ``1``]) ||  ` `                ``(j == n - ``1` `&& A[j] > GE[j - ``1``]) || ` `                ``(A[j] < SE[j + ``1``] && A[j] > GE[j - ``1``])) ` `                ``return` `A[j]; ` `        ``} ` ` `  `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] A = {``4``, ``3``, ``2``, ``5``, ``8``, ``6``, ``7``}; ` `        ``int` `n = A.length; ` `        ``System.out.println(FindElement(A, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## C#

 `// Simple C# program to find ` `// a partition point in an array ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Returns an element that has all ` `    ``// the element to its left smaller  ` `    ``// and to its right greater ` `    ``static` `int` `FindElement(``int``[] A, ``int` `n) ` `    ``{ ` `        ``// Create an array 'SE[]' that will ` `        ``// store smaller element on right side. ` `        ``int``[] SE = ``new` `int``[n]; ` ` `  `        ``// Create an another array 'GE[]' that will  ` `        ``// store greatest element on left side. ` `        ``int``[] GE = ``new` `int``[n]; ` ` `  `        ``// initialize first and last index of SE[], GE[] ` `        ``GE = A; ` `        ``SE[n - 1] = A[n - 1]; ` ` `  `        ``// store greatest element from left to right ` `        ``for` `(``int` `i = 1; i < n; i++)  ` `        ``{ ` `            ``if` `(GE[i - 1] < A[i]) ` `                ``GE[i] = A[i]; ` `            ``else` `                ``GE[i] = GE[i - 1]; ` `        ``} ` ` `  `        ``// store smallest element from right to left ` `        ``for` `(``int` `i = n - 2; i >= 0; i--)  ` `        ``{ ` `            ``if` `(A[i] < SE[i + 1]) ` `                ``SE[i] = A[i]; ` `            ``else` `                ``SE[i] = SE[i + 1]; ` `        ``} ` ` `  `        ``// Now find a number which is greater then all ` `        ``// elements at it's left and smaller the all ` `        ``// then elements to it's right ` `        ``for` `(``int` `j = 0; j < n; j++)  ` `        ``{ ` `            ``if` `((j == 0 && A[j] < SE[j + 1]) || ` `                ``(j == n - 1 && A[j] > GE[j - 1]) ||  ` `                ``(A[j] < SE[j + 1] && A[j] > GE[j - 1])) ` `                ``return` `A[j]; ` `        ``} ` ` `  `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[] A = {4, 3, 2, 5, 8, 6, 7}; ` `        ``int` `n = A.Length; ` `        ``Console.WriteLine(FindElement(A, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m . `

## PHP

 `= ``\$A``[``\$i``]) ` `            ``{ ` `                ``\$flag` `= 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// check All the elements on  ` `        ``// its right are Greater ` `        ``for` `(``\$j` `= ``\$i` `+ 1; ``\$j` `< ``\$n``; ``\$j``++) ` `            ``if` `(``\$A``[``\$j``] <= ``\$A``[``\$i``])  ` `            ``{ ` `                ``\$flag` `= 1; ` `                ``break``; ` `            ``} ` ` `  `        ``// If flag == 0 indicates we ` `        ``// found that number ` `        ``if` `(``\$flag` `== 0) ` `            ``return` `\$A``[``\$i``]; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Driver code ` `\$A` `= ``array``(4, 3, 2, 5, 8, 6, 7); ` `\$n` `= sizeof(``\$A``); ` `echo``(FindElement(``\$A``, ``\$n``)); ` ` `  `// This code is contributed  ` `// by Mukul Singh ` `?> `

Output:

```5
```

Time complexity: O(n)
Auxiliary Space: O(n)

This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.