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

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++

#include <bits/stdc++.h>
using namespace std;

// function for ceiling in left side for every element in an
// array
void 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 code
int 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_

Java

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

Python3

import sys

# function for ceiling in left side for every element in an
# array
def 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 code
arr = [ 10, 5, 11, 10, 20, 12 ]
n = len(arr)
printPrevGreater(arr, n)

# This code is contributed by shinjanpatra

C#

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

Javascript

<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++

// 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 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;
}

Java

// Java implementation of efficient algorithm
// to find greater or same element on left side
import 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

# Python3 implementation of efficient algorithm
# to find greater or same element on left side

# Prints greater elements
# on left side of every element
def 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 Code
if __name__ == "__main__":

    arr = [10, 5, 11, 10, 20, 12]
    n = len(arr)
    printPrevGreater(arr, n)

# This code is contributed by Rituraj Jain

C#

// C# implementation of efficient algorithm
// to find greater or same element on left side
using 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

Javascript

<script>


// Javascript implementation of efficient algorithm to find
// greater or same element on left side

// To get the minimum value
function minimum(ss)
{
    var min = 1000000000;
    ss.forEach(i => {
        if (i < min)
            min = i;
    });
    return min;
}
// Prints greater elements on left side of every element
function 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>

Output:

-1 10 -1 10 -1 20

Time Complexity: O(n Log n)

Auxiliary Space: O(n)