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

21 Feb, 2022
Given an array of integers, find the closest (not considering the distance, but value) greater or the same value on the left of every element. If an element has no greater or same value on the left side, print -1.
Examples:  
Input : arr[] = {10, 5, 11, 6, 20, 12} Output : -1, 10, -1, 10, -1, 20 The first element has nothing on the left side, so the answer for first is -1. Second, element 5 has 10 on the left, so the answer is 10. Third element 11 has nothing greater or the same, so the answer is -1. Fourth element 6 has 10 as value wise closes, so the answer is 10 Similarly, we get values for the fifth and sixth elements.
A simple solution is to run two nested loops. We pick an outer element one by one. For every picked element, we traverse toward the left of it and find the closest (value-wise) greater element. The time complexity of this solution is O(n*n)
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // function for ceiling in left side for every element in an// arrayvoid printPrevGreater(int arr[], int n){    cout << "-1"         << " "; // for first element    for (int i = 1; i < n; i++) {        int diff = INT_MAX;        for (int j = 0; j < i;             j++) // traverse left side to i-th element        {            if (arr[j] >= arr[i])                diff = min(diff, arr[j] - arr[i]);        }        if (diff == INT_MAX)            cout << "-1"                 << " "; // if not found at left side        else            cout << arr[i] + diff << " ";    }} // Driver codeint main(){    int arr[] = { 10, 5, 11, 10, 20, 12 };    int n = sizeof(arr) / sizeof(arr[0]);    printPrevGreater(arr, n);    return 0;} // This code is contributed by// @itsrahulhere_
import java.util.*;class GFG {   // function for ceiling in left side for every element in an  // array  static void printPrevGreater(int arr[], int n) {    System.out.print("-1" + " "); // for first element    for (int i = 1; i < n; i++) {      int diff = Integer.MAX_VALUE;      for (int j = 0; j < i; j++) // traverse left side to i-th element      {        if (arr[j] >= arr[i])          diff = Math.min(diff, arr[j] - arr[i]);      }      if (diff == Integer.MAX_VALUE)        System.out.print("-1" + " "); // if not found at left side      else        System.out.print(arr[i] + diff + " ");    }  }   // Driver code  public static void main(String[] args) {    int arr[] = { 10, 5, 11, 10, 20, 12 };    int n = arr.length;    printPrevGreater(arr, n);  }} // This code is contributed by Rajput-Ji
import sys # function for ceiling in left side for every element in an# arraydef printPrevGreater(arr,n):     print("-1",end = ' ')  # for first element    for i in range(1,n):        diff = sys.maxsize        for j in range(i): # traverse left side to i-th element             if (arr[j] >= arr[i]):                diff = min(diff, arr[j] - arr[i])        if diff == sys.maxsize :            print("-1",end = " ") # if not found at left side        else :            print(arr[i] + diff ,end = ' ') # Driver codearr = [ 10, 5, 11, 10, 20, 12 ]n = len(arr)printPrevGreater(arr, n) # This code is contributed by shinjanpatra
using System; public class GFG {   // function for ceiling in left side for every element in an  // array  static void printPrevGreater(int []arr, int n) {    Console.Write("-1" + " "); // for first element    for (int i = 1; i < n; i++) {      int diff = int.MaxValue;      for (int j = 0; j < i; j++) // traverse left side to i-th element      {        if (arr[j] >= arr[i])          diff = Math.Min(diff, arr[j] - arr[i]);      }      if (diff == int.MaxValue)        Console.Write("-1" + " "); // if not found at left side      else        Console.Write(arr[i] + diff + " ");    }  }   // Driver code  public static void Main(String[] args) {    int []arr = { 10, 5, 11, 10, 20, 12 };    int n = arr.Length;    printPrevGreater(arr, n);  }} // This code is contributed by Rajput-Ji
<script>    // function for ceiling in left side for every element in an    // array    function printPrevGreater(arr , n) {        document.write("-1" + " "); // for first element        for (i = 1; i < n; i++) {            var diff = Number.MAX_VALUE;            for (j = 0; j < i; j++) // traverse left side to i-th element            {                if (arr[j] >= arr[i])                    diff = Math.min(diff, arr[j] - arr[i]);            }            if (diff == Number.MAX_VALUE)                document.write("-1" + " "); // if not found at left side            else                document.write(arr[i] + diff + " ");        }    }     // Driver code             var arr = [ 10, 5, 11, 10, 20, 12 ];        var n = arr.length;        printPrevGreater(arr, n); // This code is contributed by Rajput-Ji</script>
Output: 
-1 10 -1 10 -1 20
Time Complexity: O(n * n)Auxiliary Space: O(1) 
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 the closest greater element. This function works in Log n time for a set. 
C++
Java
Python3
C#
Javascript
// C++ implementation of efficient algorithm to find// greater or same element on left side#include <iostream>#include <set>using namespace std; // Prints greater elements on left side of every elementvoid 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;}
// Java implementation of efficient algorithm// to find greater or same element on left sideimport java.util.TreeSet; class GFG {     // Prints greater elements on left side    // of every element    static void printPrevGreater(int[] arr, int n)    {        TreeSet<Integer> ts = new TreeSet<>();        for (int i = 0; i < n; i++) {            Integer c = ts.ceiling(arr[i]);            if (c == null) // If no greater found                System.out.print(-1 + " ");            else                System.out.print(c + " ");             // Then insert            ts.add(arr[i]);        }    }     // Driver Code    public static void main(String[] args)    {        int[] arr = { 10, 5, 11, 10, 20, 12 };        int n = arr.length;        printPrevGreater(arr, n);    }} // This code is contributed by// sanjeev2552
# Python3 implementation of efficient algorithm# to find greater or same element on left side # Prints greater elements# on left side of every elementdef printPrevGreater(arr, n):     s = set()    for i in range(0, n):         # First search in set        it = [x for x in s if x >= arr[i]]        if len(it) == 0: # If no greater found            print("-1", end = " ")        else:                            print(min(it), end = " ")                 # Then insert        s.add(arr[i]) # Driver Codeif __name__ == "__main__":     arr = [10, 5, 11, 10, 20, 12]    n = len(arr)    printPrevGreater(arr, n)     # This code is contributed by Rituraj Jain
// C# implementation of efficient algorithm// to find greater or same element on left sideusing System;using System.Collections.Generic; class GFG {     // To get the minimum value    static int minimum(SortedSet<int> ss)    {        int min = int.MaxValue;         foreach(int i in ss) if (i < min)            min = i;         return min;    }     // Prints greater elements on left side    // of every element    static void printPrevGreater(int[] arr, int n)    {        SortedSet<int> s = new SortedSet<int>();         for (int i = 0; i < n; i++) {            SortedSet<int> ss = new SortedSet<int>();             // First search in set            foreach(int x in s) if (x >= arr[i])                ss.Add(x);             if (ss.Count == 0) // If no greater found                Console.Write(-1 + " ");            else                Console.Write(minimum(ss) + " ");             // Then insert            s.Add(arr[i]);        }    }     // Driver Code    public static void Main(String[] args)    {        int[] arr = { 10, 5, 11, 10, 20, 12 };        int n = arr.Length;        printPrevGreater(arr, n);    }} // This code is contributed by PrinciRaj1992
<script>   // Javascript implementation of efficient algorithm to find// greater or same element on left side // To get the minimum valuefunction minimum(ss){    var min = 1000000000;    ss.forEach(i => {        if (i < min)            min = i;    });    return min;}// Prints greater elements on left side of every elementfunction printPrevGreater(arr, n){    var s = new Set();    for (var i = 0; i < n; i++) {         var ss = new Set();          // First search in set         s.forEach(x => {                if(x >= arr[i])                    ss.add(x);         });                      if (ss.size == 0) // If no greater found                document.write(-1 + " ");            else                document.write(minimum(ss) + " ");         // Then insert        s.add(arr[i]);    }} /* Driver program to test insertion sort */var arr = [10, 5, 11, 10, 20, 12];var n = arr.length;printPrevGreater(arr, n);  </script>
-1 10 -1 10 -1 20
 
Time Complexity: O(n Log n)
Auxiliary Space: O(n)  
rituraj_jain
sanjeev2552
princiraj1992
importantly
manpreetsingh78923
itsrahulhere_
Rajput-Ji
shinjanpatra
cpp-set
Self-Balancing-BST
Arrays
Binary Search Tree
Arrays
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.