Sort Elements by Frequency in Java

An array of integers is given. Some elements of the array are repeated. Our task is to return an array or list of the provided elements in the decreasing order of their frequency of occurrence. In other words, the element which has the highest frequency of occurrence should come first. If the frequency of occurrence of any two elements matches, then the element that comes first in the input array should come first in the output array.

Example 1:

Input:

inputArr[] = {12, 16, 15, 12, 12, 18, 15, 18, 16, 18, 18}

Output:

resultArr[] = {18, 18, 18, 18, 12, 12, 12, 16, 16, 15, 15}

Explanation: Element 18 has the heighest frequency of occurrence, as its frequency count is 4. Then, element 12 has the heighest frequency of occurrence, as its frequency count is 3. Then, there is a tie between the frequency of occurrence of elements 16 and 15. Since, the element 16 occurs first therefore the element 16 has been put before the element 15.

Example 2:

Input:

inputArr[] = {19, 20, 17, 45, 34, 3, 2, 1, 89, 56, 80, 85, 90}

Output:

resultArr[] = {19, 20, 17, 45, 34, 3, 2, 1, 89, 56, 80, 85, 90}

Explanation: Each element has the same frequency of occurrence, which is 1. Therefore, the order in which the elements are there in the input array is the same as the order in which the elements are occurring in the output array.

Approach

The concept is to sort the element on the basis of the highest to the lowest occurrence of frequency of elements. In order to avoid conflict, maintain the occurrence index of the elements on the basis of their occurrence in the input array.

Algorithm

Step 1: The concept is to implement the customized comparison method in order to solve the problem. Let the two elements that have to be compared be 'n1' and 'n2'. Then.

If 'n1' and 'n2' have different occurrences of frequencies, then put the element of higher frequency before the element that has the lower frequency.
If 'n1' and 'n2' have the same occurrence of frequencies, then that element that is occurring before in the input array should be put before the element that is occurring later in the input array.

Step 2: For each element, put it into the dictionary along with its frequency and the index of its first occurrence in the input array.

Step 3: Sort the values of elements on the basis of a custom comparator and eventually return the sorted list having the arranged elements.

Implementation

Observe the implementation of the above algorithm.

FileName: SortEleByFreq.java

// important import statements
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.Comparator;
class Comparison implements Comparator<ArrayList<Integer>>
{
    public int compare(ArrayList<Integer> al1 , ArrayList<Integer> al2)
    {   
        // frequency of element present in the list al1
        int x1 = al1.get(0);        
        // frequency of element present in the list al2
        int x2 = al2.get(0);
        // index of the first occurrence of the element present in the list al1
        int y1 = al1.get(1);
        // index of the first occurrence of the element present in the list al2
        int y2 = al2.get(1);        
        // if the frequency of occurrence of the elements do not 
        // match return the difference of x2 and x1
        if(x1 != x2)
        {
           return x2 - x1;
        }
        // if the frequency of occurrence of the elements match 
        // return the difference of the indices of their first occurrence 
        else
        {
           return y1 - y2;
        }
    }
}
public class SortEleByFreq 
{
    public int[] sortByFreq(int inputArr[]) 
    {
        HashMap<Integer, Integer> hm = new HashMap<>();
        HashMap<Integer, Integer> idx = new HashMap<>();
        // For each element of the array, put it in the dictionary and its index and frequency of the 
        // first occurrence in the array
        for (int i = 0; i < inputArr.length; i++) 
        {
            if(hm.containsKey(inputArr[i]))
            {   
                // reaching here means, the element inputArr[i]
                // has already been found. Therefore, all we have to 
                // do is to increase its frequency
                hm.put(inputArr[i], hm.get(inputArr[i]) + 1);
            }
            else
            {
                // if the inputArr[i], is found only once
                // put it in the hash map with the frequency of occurrence as 1
                hm.put(inputArr[i] , 1);
            }
            if (idx.containsKey(inputArr[i]) == false) 
            {
                // keeping track of the first occurrence 
                // of the element present in the input array
                idx.put(inputArr[i], i);
            }
        }
        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
        for (Map.Entry<Integer , Integer> itr : hm.entrySet()) 
        {
            // the list contains three elements 
            // the first one contains the frequency of the occurrence
            // the second one contains the index of the first occurrence of the element in the input array
            // the third element contains the element whose frequency has been stored as the first element 
            // in the tmp list
            ArrayList<Integer> tmp = new ArrayList<>();
            tmp.add(itr.getValue());
            tmp.add(idx.get(itr.getKey()));
            tmp.add(itr.getKey());
            list.add(tmp);
        }

        // Sorting the values using the custom comparator.
        // instantiating the Comparison class
        Collections.sort(list, new Comparison());

        // Eventually returning the sorted list having the arranged elements.
        ArrayList<Integer> ansList = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) 
        {
            for (int i = 1; i <= list.get(j).get(0); i++) 
            {
                ansList.add(list.get(j).get(2));
            }
        }
        
        int resultArr[] = new int[ansList.size()];
        
        // copying the results in the resultArr
        for(int j = 0 ; j < ansList.size() ; j++)
        {
            resultArr[j] = ansList.get(j);
        }
        return resultArr;
    }
    // main method
    public static void main(String argvs[])
    {
        // input 1
        int inputArr[] = {12, 16, 15, 12, 12, 18, 15, 18, 16, 18, 18};        
        // creating an object of the class SortEleByFreq
        SortEleByFreq obj = new SortEleByFreq();
        int resultArr[] = obj.sortByFreq(inputArr);
        int size = resultArr.length;
        System.out.println("The input array is: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(inputArr[i] + " ");
        }
        System.out.println("\n ");
        System.out.println("After sorting by frequency of occurrences, the array becomes: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(resultArr[i] + " ");
        }
        System.out.println("\n ");
        // input 2
        int inputArr1[] = {19, 20, 17, 45, 34, 3, 2, 1, 89, 56, 80, 85, 90};
        int resultArr1[] = obj.sortByFreq(inputArr1);
        size = resultArr1.length;
        System.out.println("The input array is: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(inputArr1[i] + " ");
        }
        System.out.println("\n ");
        System.out.println("After sorting by frequency of occurrences, the array becomes: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(inputArr1[i] + " ");
        }
        
        System.out.println("\n ");
    }
}

Output:

The input array is: 
12 16 15 12 12 18 15 18 16 18 18 
After sorting by frequency of occurrences, the array becomes: 
18 18 18 18 12 12 12 16 16 15 15 
The input array is: 
19 20 17 45 34 3 2 1 89 56 80 85 90 
After sorting by frequency of occurrences, the array becomes: 
19 20 17 45 34 3 2 1 89 56 80 85 90

Complexity Analysis: Since we are applying sorting, therefore the time complexity of the program is O(n * log(n)). We have also created an array list for storing the results. Thus making the space complexity O(n), where n denotes the total number of elements present in the input array.

Next TopicBeautiful Array in Java

← prev next →