Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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)

Implementation:

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

// JavaScript program for finding ceiling in left side for every
// element in an array
 
// function for ceiling in left side for every element in an
// array
function printPrevGreater(arr, n) {
    console.log("-1" + " "); // for first element
    for (let i = 1; i < n; i++) {
        let diff = Number.MAX_VALUE;
        for (let 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)
            console.log("-1" + " "); // if not found at left side
        else
            console.log(arr[i] + diff + " ");
    }
}
 
// Driver code
let arr = [10, 5, 11, 10, 20, 12];
let n = arr.length;
printPrevGreater(arr, n);
//This code is contributed by chinmaya121221

                    

Output
-1 10 -1 10 -1 20 

Complexity Analysis:

  • 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. 

Implementation:

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

// JavaScript implementation of efficient algorithm
// to find greater or same element on left side
 
// Prints greater elements on left side
// of every element
function printPrevGreater(arr, n) {
    let ts = new Set();
    for (let i = 0; i < n; i++) {
        let c = null;
        ts.forEach((item) => {
            if (item >= arr[i]) {
                c = item;
                return;
            }
        });
        if (c == null) // If no greater found
            console.log("-1 ");
        else
            console.log(c + " ");
        // Then insert
        ts.add(arr[i]);
    }
}
 
// Driver Code
let arr = [10, 5, 11, 10, 20, 12];
let n = arr.length;
printPrevGreater(arr, n);
//This code is contributed by chinmaya121221

                    

Output
-1 10 -1 10 -1 20 

Complexity Analysis:

  • Time Complexity: O(n Log n)
  • Auxiliary Space: O(n) 


Last Updated : 21 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads