Given an array of integers, sort the array according to frequency of elements. If frequencies of two elements are same, print them in increasing order. Examples:

Input : arr[] = {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}
Output : 3 3 3 3 2 2 2 12 12 4 5
Explanation :
No. Freq
2  : 3
3  : 4
4  : 1
5  : 1
12 : 2

We have discussed different approaches in below posts : Sort elements by frequency | Set 1 Sort elements by frequency | Set 2 We can solve this problem using map and pairs. Initially we create a map such that map[element] = freq. Once we are done building the map, we create an array of pairs. A pair which stores elements and their corresponding frequency will be used for the purpose of sorting. We write a custom compare function which compares two pairs firstly on the basis of freq and if there is a tie on the basis of values.

Below is its c++ implementation :

Try It Yourself

C++

// C++ program to sort elements by frequency using
// STL
#include <bits/stdc++.h>
using namespace std;

// function to compare two pairs for inbuilt sort
bool compare(pair<int,int> &p1,
            pair<int, int> &p2)
{
    // If frequencies are same, compare
    // values
    if (p1.second == p2.second)
        return p1.first < p2.first;
    return p1.second > p2.second;
}

// function to print elements sorted by freq
void printSorted(int arr[], int n)
{
    // Store items and their frequencies
    map<int, int> m;
    for (int i = 0; i < n; i++)
        m[arr[i]]++;

    // no of distinct values in the array
    // is equal to size of map.
    int s = m.size();

    // an array of pairs
    pair<int, int> p[s];

    // Fill (val, freq) pairs in an array
    // of pairs.
    int i = 0;
    for (auto it = m.begin(); it != m.end(); ++it)
        p[i++] = make_pair(it->first, it->second);

    // sort the array of pairs using above
    // compare function.
    sort(p, p + s, compare);

    cout << "Elements sorted by frequency are: ";
    for (int i = 0; i < s; i++)
    {
        int freq = p[i].second;
        while (freq--)
            cout << p[i].first << " ";
    }
}

// driver program
int main()
{
    int arr[] = {2, 3, 2, 4, 5, 12, 2, 3,
                3, 3, 12};
    int n = sizeof(arr)/ sizeof(arr[0]);
    printSorted(arr, n);
    return 0;
}

Java

// Java program to sort elements by frequency using
import java.util.*;

public class Main 
{
  
    // function to compare two pairs for inbuilt sort
    static boolean compare(Map.Entry<Integer, Integer> p1,
                           Map.Entry<Integer, Integer> p2)
    {
        // If frequencies are same, compare values
        if (p1.getValue().equals(p2.getValue()))
            return p1.getKey() < p2.getKey();
        return p1.getValue() > p2.getValue();
    }

    // function to print elements sorted by freq
    static void printSorted(int[] arr, int n)
    {
        // Store items and their frequencies
        Map<Integer, Integer> m
            = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++)
            m.put(arr[i], m.getOrDefault(arr[i], 0) + 1);

        // no of distinct values in the array
        // is equal to size of map.
        int s = m.size();

        // an array of Map.Entry pairs
        List<Map.Entry<Integer, Integer> > list
            = new ArrayList<Map.Entry<Integer, Integer> >(
                m.entrySet());

        // sort the list of Map.Entry pairs using above
        // compare function.
        Collections.sort(
            list, (p1, p2) -> compare(p1, p2) ? -1 : 1);

        System.out.print(
            "Elements sorted by frequency are: ");
        for (Map.Entry<Integer, Integer> entry : list) {
            int freq = entry.getValue();
            while (freq-- > 0)
                System.out.print(entry.getKey() + " ");
        }
    }

    // driver program
    public static void main(String[] args)
    {
        int[] arr = { 2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12 };
        int n = arr.length;
        printSorted(arr, n);
    }
}

Python3

from collections import Counter

# function to compare two elements for inbuilt sort
def compare(x, y):
    # If frequencies are same, compare
    # values
    if x[1] == y[1]:
        return x[0] < y[0]
    return x[1] > y[1]

# function to print elements sorted by freq
def printSorted(arr, n):
    # Store items and their frequencies
    m = Counter(arr)

    # no of distinct values in the array
    # is equal to size of dictionary.
    s = len(m)

    # an array of pairs
    p = [(k, v) for k, v in m.items()]

    # sort the array of pairs using above
    # compare function.
    p = sorted(p, key=lambda x: compare(x, x))

    print("Elements sorted by frequency are: ", end='')
    for i in range(s):
        freq = p[i][1]
        while freq > 0:
            print(p[i][0], end=' ')
            freq -= 1

# driver program
arr = [2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12]
n = len(arr)
printSorted(arr, n)

# This code is contributed by shiv1o43g

using System;
using System.Collections.Generic;
using System.Linq;

public class MainClass
{
  // function to compare two pairs for inbuilt sort
  static bool compare(KeyValuePair<int, int> p1, KeyValuePair<int, int> p2)
  {
    // If frequencies are same, compare values
    if (p1.Value == p2.Value)
      return p1.Key < p2.Key;
    return p1.Value > p2.Value;
  }

  // function to print elements sorted by freq
  static void printSorted(int[] arr, int n)
  {
    // Store items and their frequencies
    Dictionary<int, int> m = new Dictionary<int, int>();
    for (int i = 0; i < n; i++)
    {
      if (m.ContainsKey(arr[i]))
        m[arr[i]]++;
      else
        m[arr[i]] = 1;
    }

    // no of distinct values in the array
    // is equal to size of dictionary.
    int s = m.Count;

    // an array of KeyValuePair pairs
    List<KeyValuePair<int, int>> list =
      new List<KeyValuePair<int, int>>(m);

    // sort the list of KeyValuePair pairs using above
    // compare function.
    list.Sort((p1, p2) => compare(p1, p2) ? -1 : 1);

    Console.Write("Elements sorted by frequency are: ");
    foreach (KeyValuePair<int, int> entry in list)
    {
      int freq = entry.Value;
      while (freq-- > 0)
        Console.Write(entry.Key + " ");
    }
  }

  // driver program
  public static void Main(string[] args)
  {
    int[] arr = { 2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12 };
    int n = arr.Length;
    printSorted(arr, n);
  }
}

JavaScript

// function to compare two pairs for sorting
function compare(p1, p2)
{

  // If frequencies are same, compare values
  if (p1[1] == p2[1]) {
    return p1[0] < p2[0];
  }
  return p1[1] > p2[1];
}

// function to print elements sorted by frequency
function printSorted(arr)
{

  // Store items and their frequencies
  let m = new Map();
  for (let i = 0; i < arr.length; i++) {
    if (m.has(arr[i])) {
      m.set(arr[i], m.get(arr[i]) + 1);
    } else {
      m.set(arr[i], 1);
    }
  }

  // no of distinct values in the array
  // is equal to size of map.
  let s = m.size;

  // an array of pairs
  let p = new Array(s);

  // Fill (val, freq) pairs in an array of pairs.
  let i = 0;
  for (let [key, value] of m) {
    p[i] = [key, value];
    i++;
  }

  // sort the array of pairs using insertion sort algorithm
  for (let i = 1; i < s; i++) {
    let j = i - 1;
    let key = p[i];
    while (j >= 0 && compare(p[j], key)) {
      p[j + 1] = p[j];
      j = j - 1;
    }
    p[j + 1] = key;
  }

  process.stdout.write("Elements sorted by frequency are: ");
  for (let i = s-1; i >= 0; i--) {
    let freq = p[i][1];
    while (freq--) {
      process.stdout.write(p[i][0] + " ");
    }
  }
}

// driver program
let arr = [2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12];
printSorted(arr);

Output

Elements sorted by frequency are: 3 3 3 3 2 2 2 12 12 4 5

Time Complexity : O(n Log n)

Space Complexity: O(n)
The above algorithm requires O(n) space for the hash map and the array of pairs.

Sort elements by frequency using STL

Explore