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++ 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); |
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.