# Closest greater or same value on left side for every element in array

Given an array of integers, find the closest (not considering distance, but value) greater or same value on left of every element. If an element has no greater or same value on left side, print -1.

Examples:

Input : arr[] = {10, 5, 11, 6, 20, 12}
Output : -1, 10, -1, 10, -1, 20
First element has nothing on left side, so answer for first is -1.
Second element 5 has 10 on left, so answer is 10.
Third element 11 has nothing greater or same, so answer is -1.
Fourth element 6 has 10 as value wise closes, so answer is 10
Similarly we get values for fifth and sixth elements.

Input : arr[] = {10, 5, 11, 10, 20, 12}
Output : -1, 10, -1, 10, -1, 20

A simple solution is to run two nested loops. We pick an outer element one by one. For every picked element, we traverse toward left of it and find the closest (value wise) greater element. Time complexity of this solution is O(n*n)

An efficient solution is to use Self Balancing BST (Implemented as set in C++ and TreeSet in Java). In a Self Balancing BST, we can do both insert and closest greater operations in O(Log n) time.

We use lower_bound() in C++ to find closest greater element. This function works in Log n time for a set.

 `// C++ implementation of efficient algorithm to find ` `// greater or same element on left side ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Prints greater elements on left side of every element ` `void` `printPrevGreater(``int` `arr[], ``int` `n) ` `{ ` `    ``set<``int``> s; ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// First search in set ` `        ``auto` `it = s.lower_bound(arr[i]); ` `        ``if` `(it == s.end())   ``// If no greater found ` `            ``cout << ``"-1"` `<< ``" "``; ` `        ``else`                    `            ``cout << *it << ``" "``;         ` ` `  `        ``// Then insert ` `        ``s.insert(arr[i]); ` `    ``} ` `} ` ` `  `/* Driver program to test insertion sort */` `int` `main() ` `{ ` `    ``int` `arr[] = {10, 5, 11, 10, 20, 12}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``printPrevGreater(arr, n); ` `    ``return` `0; ` `} `

Output:

```-1 10 -1 10 -1 20
```

Time Complexity : O(n Log n)

My Personal Notes arrow_drop_up