Count of larger elements on right side of each element in an array

// Java program for the above approach

import java.util.*;

public class GFG {

    // Stores the index & value pairs
    static class Item {

        int val;
        int index;

        public Item(int val, int index)
        {
            this.val = val;
            this.index = index;
        }
    }

    // Function to count the number of
    // greater elements on the right
    // of every array element
    public static ArrayList<Integer>
    countLarge(int[] a)
    {
        // Length of the array
        int len = a.length;

        // Stores the index-value pairs
        Item[] items = new Item[len];

        for (int i = 0; i < len; i++) {
            items[i] = new Item(a[i], i);
        }

        // Stores the count of greater
        // elements on right
        int[] count = new int[len];

        // Perform MergeSort operation
        mergeSort(items, 0, len - 1,
                  count);

        ArrayList<Integer> res = new ArrayList<>();

        for (int i : count) {
            res.add(i);
        }

        return res;
    }

    // Function to sort the array
    // using Merge Sort
    public static void mergeSort(
        Item[] items, int low ,int high,
        int[] count)
    {

        // Base Case
        if (low >= high) {
            return;
        }

        // Find Mid
        int mid = low + (high - low) / 2;

        mergeSort(items, low, mid,
                  count);
        mergeSort(items, mid + 1,
                  high, count);

        // Merging step
        merge(items, low, mid,
              mid + 1, high, count);
    }

    // Utility function to merge sorted
    // subarrays and find the count of
    // greater elements on the right
    public static void merge(
        Item[] items, int low, int lowEnd,
        int high, int highEnd, int[] count)
    {
        int m = highEnd - low + 1; // mid

        Item[] sorted = new Item[m];

        int rightCounter = 0;
        int lowInd = low, highInd = high;
        int index = 0;

        // Loop to store the count of
        // larger elements on right side
        // when both array have elements
        while (lowInd <= lowEnd
               && highInd <= highEnd) {

            if (items[lowInd].val
                < items[highInd].val) {
                rightCounter++;
                sorted[index++]
                    = items[highInd++];
            }
            else {
                count[items[lowInd].index] += rightCounter;
                sorted[index++] = items[lowInd++];
            }
        }

        // Loop to store the count of
        // larger elements in right side
        // when only left array have
        // some element
        while (lowInd <= lowEnd) {

            count[items[lowInd].index] += rightCounter;
            sorted[index++] = items[lowInd++];
        }

        // Loop to store the count of
        // larger elements in right side
        // when only right array have
        // some element
        while (highInd <= highEnd) {

            sorted[index++] = items[highInd++];
        }

        System.arraycopy(sorted, 0, items,
                         low, m);
    }

    // Utility function that prints
    // the count of greater elements
    // on the right
    public static void
    printArray(ArrayList<Integer> countList)
    {

        for (Integer i : countList)
            System.out.print(i + " ");

        System.out.println();
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given array
        int arr[] = { 3, 7, 1, 5, 9, 2 };
        int n = arr.length;

        // Function Call
        ArrayList<Integer> countList
            = countLarge(arr);

        printArray(countList);
    }
}

import java.util.*;

public class Main {
    // Helper function to count the number of elements greater than 'item' in the sorted 'list'
    public static int countLargeNumbers(int item, List<Integer> list) {
        int l = 0;
        int r = list.size() - 1;
        int mid = 0;
        while (l < r) {
            mid = l + (r - l) / 2;
            if (list.get(mid) > item) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        if (l == r && item > list.get(l)) {
            return 0;
        }
        return list.size() - l;
    }

    // Helper function to delete the first occurrence of 'item' from the sorted 'list'
    public static void deleteItemFromSortedList(List<Integer> list, int item) {
        int index = Collections.binarySearch(list, item);
        if (index >= 0) {
            list.remove(index);
        }
    }

    // Function to count the number of elements greater than each element in the input list 'list'
    public static List<Integer> countLarge(List<Integer> list) {
        // Create a sorted copy of the input list
        List<Integer> sortedList = new ArrayList<>(list);
        Collections.sort(sortedList);

        // For each element in the input list, count the number of elements greater than it
        for (int i = 0; i < list.size(); i++) {
            deleteItemFromSortedList(sortedList, list.get(i));
            list.set(i, countLargeNumbers(list.get(i), sortedList));
        }
        return list;
    }

    // Helper function to print the contents of a list
    public static void printList(List<Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
    }

    // Main function
    public static void main(String[] args) {
        // Create an input list
        List<Integer> arr = new ArrayList<>(Arrays.asList(3, 7, 1, 5, 9, 2));

        // Call the 'countLarge' function to count the number of elements greater than each element in 'arr'
        List<Integer> res = countLarge(arr);

        // Print the result list
        printList(res);
    }
}