Count greater elements on the left side of every array element - GeeksforGeeks

31 May, 2021
Given an array arr[] of distinct integers of size N, the task is to print the count of greater elements on the left side of each array element.
Examples :
Input: arr[] = {12, 1, 2, 3, 0, }Output: 0 1 1 1 4Explanation:For index 0, no greater element exists on the left side.For index 1, {12} is greater element on the left side.For index 2, {12} is greater element on the left side.For index 3, {12} is greater element on the left side.For index 4, {12, 1, 2, 3} are greater elements on the left side.Therefore, the output is 0 1 1 1 4.
Input: arr[] = {5, 4, 3, 2, 1}Output: 0 1 2 3 4
Naive Approach: The simplest approach to solve the problem is to traverse the array and for every array element, traverse towards its left and compare every element with the current element. Finally, print the count of greater elements on its left for every array element. 
Time Complexity: O(N2) Auxiliary Space: O(1)
Efficient Approach: The problem can be solved using Set containers which are implemented by Self Balancing Binary Search Tree. Follow the steps below solve the problem.
Create an empty Set, St.Traverse the array and insert every element in St one by one.Find the previous greater element of arr[i] using upper_bound function.Find the distance between the previous greater element and the last element of the set using the distance function.Store the distance in the array, countLeftGreater[].Print the array.
Create an empty Set, St.
Traverse the array and insert every element in St one by one.
Find the previous greater element of arr[i] using upper_bound function.
Find the distance between the previous greater element and the last element of the set using the distance function.
Store the distance in the array, countLeftGreater[].
Print the array.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to implement// the above approach #include <bits/stdc++.h>using namespace std; // Function to print the count of greater// elements on left of each array elementvoid display(int countLeftGreater[], int N){    for (int i = 0; i < N; i++) {        cout << countLeftGreater[i]             << " ";    }} // Function to get the count of greater// elements on left of each array elementvoid countGreater(int arr[], int N){    // Store distinct array    // elements in sorted order    set<int> St;     // Stores the count of greater    // elements on the left side    int countLeftGreater[N];     // Traverse the array    for (int i = 0; i < N; i++) {         // Insert array elements        // into the set        St.insert(arr[i]);         // Find previous greater element        auto it = St.upper_bound(arr[i]);         // Find the distance between the        // previous greater element of arr[i]        // and last element of the set        countLeftGreater[i]            = distance(it, St.end());    }    display(countLeftGreater, N);} // Driver Codeint main(){    int arr[] = { 12, 1, 2, 3, 0, 11, 4 };    int N = sizeof(arr) / sizeof(arr[0]);    countGreater(arr, N);}
// Java program to implement// the above approachimport java.util.*;import java.lang.*; class GFG{     // Function to print the count of greater// elements on left of each array elementstatic void display(int countLeftGreater[], int N){    for(int i = 0; i < N; i++)    {       System.out.print(countLeftGreater[i] + " ");    }}   // Function to get the count of greater// elements on left of each array elementstatic void countGreater(int arr[], int N){         // Store distinct array    // elements in sorted order    Set<Integer> St = new TreeSet<>();       // Stores the count of greater    // elements on the left side    int[] countLeftGreater = new int[N];       // Traverse the array    for(int i = 0; i < N; i++)    {                 // Insert array elements        // into the set        St.add(arr[i]);           int it = 0;                 // Find previous greater element        Iterator<Integer> iterator = St.iterator();        while (iterator.hasNext())        {           if (arr[i] < iterator.next())           {               break;           }           it++;        }           // Find the distance between the        // previous greater element of arr[i]        // and last element of the set        countLeftGreater[i] = Math.abs(it - St.size());    }    display(countLeftGreater, N); } // Driver codepublic static void main (String[] args){    int arr[] = { 12, 1, 2, 3, 0, 11, 4 };    int N = arr.length;         countGreater(arr, N);}} // This code is contributed by offbeat
# Python3 program to implement# the above approach # Function to print the count of greater# elements on left of each array elementdef display(countLeftGreater, N):         for i in range(N):        print(countLeftGreater[i], end = " ") # Function to get the count of greater# elements on left of each array elementdef countGreater(arr, N):         # Store distinct array    # elements in sorted order    St = set()     # Stores the count of greater    # elements on the left side    countLeftGreater = [0] * (N)         # Traverse the array    for i in range(N):                 # Insert array elements        # into the set        St.add(arr[i])         it = 0         # Find previous greater element        for st in St:            if (arr[i] < st):                break             it += 1        # Find the distance between the        # previous greater element of arr[i]        # and last element of the set        countLeftGreater[i] = abs(it - len(St))     display(countLeftGreater, N) # Driver codeif __name__ == '__main__':         arr = [ 12, 1, 2, 3, 0, 11, 4 ]    N = len(arr)     countGreater(arr, N) # This code is contributed by Rajput-Ji
// C# program to implement// the above approachusing System;using System.Collections.Generic; class GFG{     // Function to print the count of greater// elements on left of each array elementstatic void display(int []countLeftGreater, int N){    for(int i = 0; i < N; i++)    {        Console.Write(countLeftGreater[i] + " ");    }}   // Function to get the count of greater// elements on left of each array elementstatic void countGreater(int []arr, int N){         // Store distinct array    // elements in sorted order    List<int> St = new List<int>();       // Stores the count of greater    // elements on the left side    int[] countLeftGreater = new int[N];       // Traverse the array    for(int i = 0; i < N; i++)    {                 // Insert array elements        // into the set        St.Add(arr[i]);           int it = 0;        St.Sort();                 // Find previous greater element        foreach(int itr in St)        {            if (arr[i] < itr)            {                break;            }            it++;        }                 // Find the distance between the        // previous greater element of arr[i]        // and last element of the set        countLeftGreater[i] = Math.Abs(it - St.Count);    }    display(countLeftGreater, N); } // Driver codepublic static void Main(String[] args){    int []arr = { 12, 1, 2, 3, 0, 11, 4 };    int N = arr.Length;         countGreater(arr, N);}} // This code is contributed by gauravrajput1
<script>// Js program to implement// the above approach // Function to print the count of greater// elements on left of each array elementfunction display( countLeftGreater, N){    for (let i = 0; i < N; i++) {        document.write(countLeftGreater[i] ," ");    }} // Function to get the count of greater// elements on left of each array elementfunction countGreater(arr,  N){    // Store distinct array    // elements in sorted order    let St = new Set();     // Stores the count of greater    // elements on the left side    let countLeftGreater = [];     // Traverse the array    for (let i = 0; i < N; i++) {         // Insert array elements        // into the set        St.add(arr[i]);         // Find previous greater element        let it = 0;        // Find previous greater element        //let a = Array.from(St);        //a.sort(function(a,b){return a-b});                 for (let st of St){            if (arr[i] < st)            it += 1;        }        // Find the distance between the        // previous greater element of arr[i]        // and last element of the set        countLeftGreater[i]            = Math.abs(it);    }    display(countLeftGreater, N);} // Driver Codelet arr = [ 12, 1, 2, 3, 0, 11, 4 ];let N = arr.length;countGreater(arr, N);</script>
0 1 1 1 4 1 2
 
Time Complexity: O(N2) because distance function takes O(N) but the above implementation is very simple and works better than the naive algorithm in the average case. Auxiliary Space: O(N) 
Note: Above approach works for unique elements but for duplicate elements just replace Set with Multiset.
 
 
offbeat
GauravRajput1
Rajput-Ji
rohan07
nidhi_biet
cpp-set
Arrays
Hash
Mathematical
Searching
Arrays
Searching
Hash
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Internal Working of HashMap in Java
Count pairs with given sum
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)