Sort elements by frequency using STL
Last Updated :
10 Apr, 2023
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 :
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 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);
}
}
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);
}
}
// 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);
OutputElements 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.
Sample Problem - sort(): Sort array elements by frequency
Visit Course
Sample Problem - sort(): Sort array elements by frequency
Sorting Elements of an Array by Frequency | DSA Problem
Similar Reads
Sort elements by frequency Given an array of integers arr[], sort the array according to the frequency of elements, i.e. elements that have higher frequency comes first. If the frequencies of two elements are the same, then the smaller number comes first.Examples: Input: arr[] = [5, 5, 4, 6, 4]Output: [4, 4, 5, 5, 6]Explanati
15+ min read
Sort elements by frequency using Binary Search Tree Given an array of integers arr[], sort the array according to the frequency of elements, i.e. elements that have higher frequency comes first. If the frequencies of two elements are the same, then the smaller number comes first.Examples: Input: arr[] = [5, 5, 4, 6, 4]Output: [4, 4, 5, 5, 6]Explanati
15+ min read
Sort elements by frequency | Set 4 (Efficient approach using hash) Print the elements of an array in the decreasing frequency if 2 numbers have the same frequency then print the one which came first. Examples: Input : arr[] = {2, 5, 2, 8, 5, 6, 8, 8} Output : arr[] = {8, 8, 8, 2, 2, 5, 5, 6} Input : arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8} Output : arr[] = {8,
12 min read
Top K Frequent Elements in an Array Given an array arr[] and a positive integer k, the task is to find the k most frequently occurring elements from a given array.Note: If more than one element has same frequency then prioritise the larger element over the smaller one.Examples: Input: arr= [3, 1, 4, 4, 5, 2, 6, 1], k = 2Output: [4, 1]
15+ min read
Count minimum frequency elements in a linked list Given a linked list containing duplicate elements. The task is to find the count of all minimum occurring elements in the given linked list. That is the count of all such elements whose frequency is minimum in the matrix. Examples: Input : 1-> 2-> 2-> 3 Output : 2 Explanation: 1 and 3 are e
8 min read
Sorting element of an array by frequency in decreasing order Given an array arr[] of N integers. The task is to sort the array arr[] according to the frequency of elements in decreasing order. Note: If the frequencies of the two elements are the same, then the smaller element should come first. Examples: Input: arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 } Output: 4
15+ min read