Count greater elements on the left side of every array element
Last Updated :
13 Sep, 2023
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 4
Explanation:
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.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void display( int countLeftGreater[], int N)
{
for ( int i = 0; i < N; i++) {
cout << countLeftGreater[i]
<< " " ;
}
}
void countGreater( int arr[], int N)
{
set< int > St;
int countLeftGreater[N];
for ( int i = 0; i < N; i++) {
St.insert(arr[i]);
auto it = St.upper_bound(arr[i]);
countLeftGreater[i]
= distance(it, St.end());
}
display(countLeftGreater, N);
}
int main()
{
int arr[] = { 12, 1, 2, 3, 0, 11, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
countGreater(arr, N);
}
|
Java
import java.util.*;
import java.lang.*;
class GFG{
static void display( int countLeftGreater[], int N)
{
for ( int i = 0 ; i < N; i++)
{
System.out.print(countLeftGreater[i] + " " );
}
}
static void countGreater( int arr[], int N)
{
Set<Integer> St = new TreeSet<>();
int [] countLeftGreater = new int [N];
for ( int i = 0 ; i < N; i++)
{
St.add(arr[i]);
int it = 0 ;
Iterator<Integer> iterator = St.iterator();
while (iterator.hasNext())
{
if (arr[i] < iterator.next())
{
break ;
}
it++;
}
countLeftGreater[i] = Math.abs(it - St.size());
}
display(countLeftGreater, N);
}
public static void main (String[] args)
{
int arr[] = { 12 , 1 , 2 , 3 , 0 , 11 , 4 };
int N = arr.length;
countGreater(arr, N);
}
}
|
Python3
def display(countLeftGreater, N):
for i in range (N):
print (countLeftGreater[i], end = " " )
def countGreater(arr, N):
St = set ()
countLeftGreater = [ 0 ] * (N)
for i in range (N):
St.add(arr[i])
it = 0
for st in St:
if (arr[i] < st):
break
it + = 1
countLeftGreater[i] = abs (it - len (St))
display(countLeftGreater, N)
if __name__ = = '__main__' :
arr = [ 12 , 1 , 2 , 3 , 0 , 11 , 4 ]
N = len (arr)
countGreater(arr, N)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void display( int []countLeftGreater, int N)
{
for ( int i = 0; i < N; i++)
{
Console.Write(countLeftGreater[i] + " " );
}
}
static void countGreater( int []arr, int N)
{
List< int > St = new List< int >();
int [] countLeftGreater = new int [N];
for ( int i = 0; i < N; i++)
{
St.Add(arr[i]);
int it = 0;
St.Sort();
foreach ( int itr in St)
{
if (arr[i] < itr)
{
break ;
}
it++;
}
countLeftGreater[i] = Math.Abs(it - St.Count);
}
display(countLeftGreater, N);
}
public static void Main(String[] args)
{
int []arr = { 12, 1, 2, 3, 0, 11, 4 };
int N = arr.Length;
countGreater(arr, N);
}
}
|
Javascript
<script>
function display( countLeftGreater, N)
{
for (let i = 0; i < N; i++) {
document.write(countLeftGreater[i] , " " );
}
}
function countGreater(arr, N)
{
let St = new Set();
let countLeftGreater = [];
for (let i = 0; i < N; i++) {
St.add(arr[i]);
let it = 0;
for (let st of St){
if (arr[i] < st)
it += 1;
}
countLeftGreater[i]
= Math.abs(it);
}
display(countLeftGreater, N);
}
let arr = [ 12, 1, 2, 3, 0, 11, 4 ];
let N = arr.length;
countGreater(arr, N);
</script>
|
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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...