Sorting element of an array by frequency in decreasing order

// Java program to sort an array in
// decreasing order of their frequency
import java.util.*;

class GFG{
 
// Function that return the index
// upto all the array elements are
// updated.
static int sortByFreq(Integer []arr, int n)
{
 
    // Initialise maxE = -1
    int maxE = -1;
 
    // Find the maximum element of
    // arr[]
    for (int i = 0; i < n; i++) {
        maxE = Math.max(maxE, arr[i]);
    }
 
    // Create frequency array freq[]
    int freq[] = new int[maxE + 1];
 
    // Update the frequency array as
    // per the occurrence of element in
    // arr[]
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
 
    // Initialise cnt to 0
    int cnt = 0;
 
    // Traversing freq[]
    for (int i = 0; i <= maxE; i++) {
 
        // If freq of an element is
        // greater than 0 update the
        // value of arr[] at index cnt
        // & increment cnt
        if (freq[i] > 0) {
 
            int value = 100000 - i;
            arr[cnt] = 100000 * freq[i] + value;
            cnt++;
        }
    }
 
    // Return cnt
    return cnt;
}
 
// Function that print array arr[]
// elements in sorted order
static void printSortedArray(Integer []arr, int cnt)
{
 
    // Traversing arr[] till index cnt
    for (int i = 0; i < cnt; i++) {
 
        // Find frequency of elements
        int frequency = arr[i] / 100000;
 
        // Find value at index i
        int value = 100000 - (arr[i] % 100000);
 
        // Traversing till frequency
        // to print value at index i
        for (int j = 0; j < frequency; j++) {
            System.out.print(value + " ");
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
 
    Integer arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 };
 
    // Size of array arr[]
    int n = arr.length;
 
    // Function call to get cnt
    int cnt = sortByFreq(arr, n);
 
    // Sort the arr[] in decreasing order
    Arrays.sort(arr, Collections.reverseOrder());
 
    // Function that prints elements
    // in decreasing order
    printSortedArray(arr, cnt);
 
}
}

// This code is contributed by sapnasingh4991

// Java code for the approach
import java.util.*;

public class Main {
    public static int compare(int[] p1, int[] p2) {
        if (p1[1] == p2[1]) //if frequency is equal
        {
            return p1[0] - p2[0]; //return the smaller value
        }
        return p2[1] - p1[1]; //return the element with greater frequency
    }

    public static void main(String[] args) {
        int[] arr = { 4, 4, 5, 6, 4, 2, 2, 8, 5 };
        int n = arr.length;
        Map<Integer, Integer> m = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            if (m.containsKey(arr[i])) {
                m.put(arr[i], m.get(arr[i]) + 1);
            } else
                m.put(arr[i], 1);
        }
        int[][] a = new int[m.size()][2];
        int i = 0;
        for (Map.Entry<Integer, Integer> x : m.entrySet()) {
            a[i][0] = x.getKey();
            a[i][1] = x.getValue();
            i++;
        }
        Arrays.sort(a, Main::compare);
        int[] ans = new int[n];
        int j = 0;
        for (int[] x : a) {
            while (x[1]-- > 0) {
                ans[j++] = x[0];
            }
        }
        for (int x : ans) {
            System.out.print(x + " ");
        }
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Input array
        int[] arr = {4, 4, 5, 6, 4, 2, 2, 8, 5};

        // Function Call
        List<Integer> ans = sortByFrequency(arr);

        // Output the sorted array
        for (int element : ans) {
            System.out.print(element + " ");
        }
    }

    // Function to sort the array according
    // to the frequency of elements
    static List<Integer> sortByFrequency(int[] arr) {
        // Create a HashMap to count the frequency of each element
        Map<Integer, Integer> freqMap = new HashMap<>();

        // Traverse through the array
        for (int element : arr) {
            freqMap.put(element, freqMap.getOrDefault(element, 0) + 1);
        }

        // Sort the elements by their frequency in descending order
        List<Map.Entry<Integer, Integer>> sortedElements = new ArrayList<>(freqMap.entrySet());
        sortedElements.sort((a, b) -> {
            int freqComparison = Integer.compare(b.getValue(), a.getValue());
            return (freqComparison == 0) ? Integer.compare(a.getKey(), b.getKey()) : freqComparison;
        });

        // Declare a new list to store the result
        List<Integer> res = new ArrayList<>();

        // Traverse through the sorted elements and
        // insert the elements in the result list
        for (Map.Entry<Integer, Integer> entry : sortedElements) {
            int element = entry.getKey();
            int freq = entry.getValue();
            for (int i = 0; i < freq; i++) {
                res.add(element);
            }
        }

        return res;
    }
}