Sort elements by frequency | Set 4 (Efficient approach using hash)

// Java program for the above approach 
import java.util.*;

// Used for sorting by frequency. And if frequency is same,
// then by appearance
class SortByValue implements Comparator<Map.Entry<Integer, Integer> > 
{ 
    // Used for sorting in descending order of values 
    public int compare(Map.Entry<Integer, Integer> o1,  
                       Map.Entry<Integer, Integer> o2) 
    { 
        // If frequency is same then sort by index
        if (o1.getValue() == o2.getValue()) 
            return o1.getKey() - o2.getKey(); 
        return o2.getValue() - o1.getValue(); 
    } 
} 

class GFG 
{ 
    // Function to sort elements by frequency
    static Vector<Integer> sortByFreq(int a[], int n) 
    { 
        // Map to store the frequency of the elements 
        HashMap<Integer, Integer> m = new HashMap<>(); 
  
        // Vector to store the sorted elements 
        Vector<Integer> v = new Vector<>(); 
  
        // Insert elements and their frequency in the map 
        for (int i = 0; i < n; i++) 
        { 
            int x = a[i]; 
            if (m.containsKey(x)) 
                m.put(x, m.get(x) + 1); 
            else
                m.put(x, 1); 
        } 
  
        // Copy map to vector 
        Vector<Map.Entry<Integer, Integer> > v1 = 
            new Vector<>(m.entrySet()); 
  
        // Sort the vector elements by frequency 
        Collections.sort(v1, new SortByValue()); 
  
        // Traverse the vector and insert elements 
        // in the vector v 
        for (int i = 0; i < v1.size(); i++) 
            for (int j = 0; j < v1.get(i).getValue(); j++) 
                v.add(v1.get(i).getKey()); 
  
        return v; 
    } 
  
    // Driver program 
    public static void main(String[] args) 
    { 
        int a[] = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 }; 
        int n = a.length; 
        Vector<Integer> v = sortByFreq(a, n); 
  
        // Print the elements of vector 
        for (int i = 0; i < v.size(); i++) 
            System.out.print(v.get(i) + " "); 
    } 
}

// Java program for the above approach
import java.util.*;

// pair class
class Pair{
    int first;
    int second;
    public Pair(int first, int second){
        this.first = first;
        this.second = second;
    }
}

public class Main{

    // map all the number and sort by frequency
    public static void the_helper(int[] a, List<Pair> res, int n){
        // create a new map to store the frequency of each number in the array
        Map<Integer, Integer> mp = new HashMap<>();
        for(int i = 0; i < n; i++){
            // check if the map already has the number, 
              // if yes, increase its count by 1, else add it to the map with count 1
            if(mp.containsKey(a[i]))
                mp.put(a[i], mp.get(a[i])+1);
            else
                mp.put(a[i], 1);
        }
        // loop through the map entries and add them to the result list as pairs
        for(Map.Entry<Integer, Integer> entry : mp.entrySet()){
            res.add(new Pair(entry.getValue(), entry.getKey()));
        }
        // sort the result list in ascending order of 
          // frequency using a lambda expression
        res.sort((x, y) -> x.first - y.first);
    }

    // driver program
    public static void main(String[] args) {
        int[] a = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8};
        List<Pair> res = new ArrayList<>();
        the_helper(a, res, 10);
        // reverse the result list to get it in descending order of frequency
        Collections.reverse(res);
        // loop through the result list and swap pairs with
          // equal frequencies if the second element of the earlier 
          // pair is greater than the second element of the later pair
        for(int i = 0; i < res.size()-1; i++){
            if(res.get(i).first == res.get(i+1).first){
                for(int j = i; j < res.size(); j++){
                    if(res.get(i).second > res.get(j).second && res.get(i).first == res.get(j).first){
                        Pair temp = res.get(j);
                        res.set(j, res.get(i));
                        res.set(i, temp);
                    }
                }
            }
        }
        System.out.println();
        // loop through the result list and print each pair's 
          //second element the number of times indicated by its first element
        for(Pair p : res){
            for(int i = 0; i < p.first; i++){
                System.out.print(p.second + " ");
            }
        }
    }
}

// this code is contributed by bhardwajji