GFG App
Open App
Browser
Continue

# 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, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}
```

We have discussed different approaches in below posts :
Sort elements by frequency | Set 1
Sort elements by frequency | Set 2
Sorting Array Elements By Frequency | Set 3 (Using STL)
All of the above approaches work in O(n Log n) time where n is total number of elements. In this post, a new approach is discussed that works in O(n + m Log m) time where n is total number of elements and m is total number of distinct elements.

The idea is to use hashing

1. We insert all elements and their counts into a hash. This step takes O(n) time where n is number of elements.
2. We copy the contents of hash to an array (or vector) and sort them by counts. This step takes O(m Log m) time where m is total number of distinct elements.
3. For maintaining the order of elements if the frequency is the same, we use another hash which has the key as elements of the array and value as the index. If the frequency is the same for two elements then sort elements according to the index.

The below image is a dry run of the above approach:

We do not need to declare another map m2, as it does not provide the proper expected result for the problem.

instead, we need to just check for the first values of the pairs sent as parameters in the sortByVal function.

Below is the implementation of the above approach:

## C++

 `//     CPP program for the above approach ` `#include ` `using` `namespace` `std;`   `// Used for sorting by frequency. And if frequency is same,` `// then by appearance` `bool` `sortByVal(``const` `pair<``int``, ``int``>& a, ` `                      ``const` `pair<``int``, ``int``>& b)` `{`   `   ``// If frequency is same then sort by index` `   ``if` `(a.second == b.second)  ` `       ``return` `a.first < b.first;`   `   ``return` `a.second > b.second;` `}`   `// function to sort elements by frequency` `vector<``int``>sortByFreq(``int` `a[], ``int` `n)` `{`   `   ``vector<``int``>res;`   `   ``unordered_map<``int``, ``int``> m;`   `   ``vector > v;`   `   ``for` `(``int` `i = 0; i < n; ++i) {`   `       ``// Map m is used to keep track of count  ` `       ``// of elements in array` `       ``m[a[i]]++;      ` `   ``}`   `   ``// Copy map to vector` `   ``copy(m.begin(), m.end(), back_inserter(v));`   `   ``// Sort the element of array by frequency` `   ``sort(v.begin(), v.end(), sortByVal);`   `   ``for` `(``int` `i = 0; i < v.size(); ++i)  ` `      ``while``(v[i].second--)` `      ``{` `              ``res.push_back(v[i].first);` `      ``}`   `   ``return` `res;` `}`   `// Driver program` `int` `main()` `{`   `   ``int` `a[] = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 };` `   ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]);` `   ``vector<``int``>res;` `   ``res = sortByFreq(a, n);`   `   ``for``(``int` `i = 0;i < res.size(); i++)` `         ``cout<

## Python3

 `# Used for sorting by frequency. And if frequency is same,` `# then by appearance` `from` `functools ``import` `cmp_to_key`   `def` `sortByVal(a,b):`   `    ``# If frequency is same then sort by index` `    ``if` `(a[``1``] ``=``=` `b[``1``]):` `        ``return` `a[``0``] ``-` `b[``0``]`   `    ``return` `b[``1``] ``-` `a[``1``]`   `# function to sort elements by frequency` `def` `sortByFreq(a, n):` `    ``res ``=` `[]` `    ``m ``=` `{}` `    ``v ``=` `[]`   `    ``for` `i ``in` `range``(n):`   `        ``# Map m is used to keep track of count` `        ``# of elements in array` `        ``if``(a[i] ``in` `m):` `            ``m[a[i]] ``=` `m[a[i]]``+``1` `        ``else``:` `            ``m[a[i]] ``=` `1`   `    ``for` `key,value ``in` `m.items():` `        ``v.append([key,value])`   `    ``# Sort the element of array by frequency` `    ``v.sort(key ``=` `cmp_to_key(sortByVal))`   `    ``for` `i ``in` `range``(``len``(v)):` `        ``while``(v[i][``1``]):` `            ``res.append(v[i][``0``])` `            ``v[i][``1``] ``-``=` `1`   `    ``return` `res`     `# Driver program`   `a ``=` `[ ``2``, ``5``, ``2``, ``6``, ``-``1``, ``9999999``, ``5``, ``8``, ``8``, ``8` `]` `n ``=` `len``(a)` `res ``=` `[]` `res ``=` `sortByFreq(a, n)`   `for` `i ``in` `range``(``len``(res)):` `    ``print``(res[i],end ``=` `" "``)`     `# This code is contributed by shinjanpatra`

## Java

 `// 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 > ` `{ ` `    ``// Used for sorting in descending order of values ` `    ``public` `int` `compare(Map.Entry o1,  ` `                       ``Map.Entry 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 sortByFreq(``int` `a[], ``int` `n) ` `    ``{ ` `        ``// Map to store the frequency of the elements ` `        ``HashMap m = ``new` `HashMap<>(); ` `  `  `        ``// Vector to store the sorted elements ` `        ``Vector 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 > 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 v = sortByFreq(a, n); ` `  `  `        ``// Print the elements of vector ` `        ``for` `(``int` `i = ``0``; i < v.size(); i++) ` `            ``System.out.print(v.get(i) + ``" "``); ` `    ``} ` `}`

## Javascript

 ``

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `// Used for sorting by frequency. And if frequency is same,` `// then by appearance` `class` `SortByValue : IComparer>` `{` `    ``// Used for sorting in descending order of values ` `    ``public` `int` `Compare(KeyValuePair<``int``, ``int``> o1, KeyValuePair<``int``, ``int``> o2)` `    ``{` `        ``// If frequency is same then sort by index` `        ``if` `(o1.Value == o2.Value)` `            ``return` `o1.Key - o2.Key;` `        ``return` `o2.Value - o1.Value;` `    ``}` `}`   `class` `GFG` `{` `    ``// Function to sort elements by frequency` `    ``static` `List<``int``> sortByFreq(``int``[] a, ``int` `n)` `    ``{` `        ``// Dictionary to store the frequency of the elements ` `        ``Dictionary<``int``, ``int``> m = ``new` `Dictionary<``int``, ``int``>();`   `        ``// List to store the sorted elements ` `        ``List<``int``> res = ``new` `List<``int``>();`   `        ``// Insert elements and their frequency in the dictionary ` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            ``int` `x = a[i];` `            ``if` `(m.ContainsKey(x))` `                ``m[x]++;` `            ``else` `                ``m.Add(x, 1);` `        ``}`   `        ``// Copy dictionary to list` `        ``List> v =` `            ``new` `List>(m);`   `        ``// Sort the list elements by frequency ` `        ``v.Sort(``new` `SortByValue());`   `        ``// Traverse the list and insert elements ` `        ``// in the list v ` `        ``foreach` `(KeyValuePair<``int``, ``int``> kvp ``in` `v)` `        ``{` `            ``for` `(``int` `i = 0; i < kvp.Value; i++)` `                ``res.Add(kvp.Key);` `        ``}`   `        ``return` `res;` `    ``}`   `    ``// Driver program ` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[] a = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 };` `        ``int` `n = a.Length;` `        ``List<``int``> res = sortByFreq(a, n);`   `        ``// Print the elements of list ` `        ``foreach` `(``int` `i ``in` `res)` `            ``Console.Write(i + ``" "``);` `    ``}` `}`

Output

`8 8 8 2 2 5 5 -1 6 9999999 `

Time Complexity: O(n) + O(m Log m) where n is total number of elements and m is total number of distinct elements
Auxiliary Space: O(n)

This article is contributed by Aarti_Rathi and Ankur Singh and improved by Ankur Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Simple way to sort by frequency.

The Approach:

Here In This approach we first we store the element by there frequency in vector_pair format(Using Mapping stl map) then sort it according to frequency then reverse it and apply bubble sort to make the condition true decreasing frequency if 2 numbers have the same frequency then print the one which came first. then print the vector.

## C++

 `#include ` `#include` `using` `namespace` `std;`   `//map all the number and sort by frequency.` `void` `the_helper(``int` `a[],vector>&res,``int` `n){` `   ``map<``int``,``int``>mp;` `   ``for``(``int` `i=0;i>res;` `  ``the_helper(a,res,10);` `  ``reverse(res.begin(),res.end());` `  ``for``(``int` `i=0;ires[j].second&&res[i].first==res[j].first){` `          ``swap(res[i],res[j]);` `        ``}` `      ``}` `    ``}` `  ``}` `  ``for``(``int` `i=0;i

## Java

 `// 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 res, ``int` `n){` `        ``// create a new map to store the frequency of each number in the array` `        ``Map 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 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 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`

## Python3

 `# python3 program for the above approach` `import` `collections`   `# map all the number and sort by frequency`     `def` `the_helper(a, res, n):` `    ``mp ``=` `collections.defaultdict(``int``)` `    ``for` `i ``in` `range``(n):` `        ``mp[a[i]] ``+``=` `1` `    ``for` `key, val ``in` `mp.items():` `        ``res.append((val, key))` `    ``res.sort()`     `# main function` `if` `__name__ ``=``=` `'__main__'``:` `    ``a ``=` `[``2``, ``5``, ``2``, ``6``, ``-``1``, ``9999999``, ``5``, ``8``, ``8``, ``8``]` `    ``res ``=` `[]` `    ``the_helper(a, res, ``len``(a))` `    ``res.reverse()` `    ``for` `i ``in` `range``(``len``(res) ``-` `1``):` `        ``if` `res[i][``0``] ``=``=` `res[i``+``1``][``0``]:` `            ``for` `j ``in` `range``(i``+``1``, ``len``(res)):` `                ``if` `res[i][``0``] ``=``=` `res[j][``0``] ``and` `res[i][``1``] > res[j][``1``]:` `                    ``res[i], res[j] ``=` `res[j], res[i]` `    ``for` `i ``in` `range``(``len``(res)):` `        ``for` `j ``in` `range``(res[i][``0``]):` `            ``print``(res[i][``1``], end``=``' '``)` `        ``# print()  # uncomment to print each frequency on a new line`

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `public` `class` `Program {` `    ``//map all the number and sort by frequency.` `    ``public` `static` `void` `the_helper(``int``[] a, List> res, ``int` `n) {` `        ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``if` `(mp.ContainsKey(a[i])) {` `                ``mp[a[i]]++;` `            ``} ``else` `{` `                ``mp[a[i]] = 1;` `            ``}` `        ``}` `        ``foreach` `(``var` `it ``in` `mp) {` `            ``res.Add(``new` `Tuple<``int``,``int``>(it.Value, it.Key));` `        ``}` `        ``res.Sort();` `    ``}`   `    ``public` `static` `void` `Main() {` `        ``int``[] a = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 };` `        ``List> res = ``new` `List>();` `        ``the_helper(a, res, 10);` `        ``res.Reverse();` `        ``for` `(``int` `i = 0; i < res.Count; i++) {` `            ``if` `(i < res.Count - 1 && res[i].Item1 == res[i+1].Item1) {` `                ``for` `(``int` `j = i; j < res.Count; j++) {` `                    ``if` `(res[i].Item2 > res[j].Item2 && res[i].Item1 == res[j].Item1) {` `                        ``var` `temp = res[i];` `                        ``res[i] = res[j];` `                        ``res[j] = temp;` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``for``(``int` `i=0;i

## Javascript

 `// JavaScript program for the above approach` `// pair class` `class pair{` `    ``constructor(first, second){` `        ``this``.first = first;` `        ``this``.second = second;` `    ``}` `}`   `// map all the number and sort by frequency` `function` `the_helper(a, res, n){` `    ``mp = ``new` `Map();` `    ``for``(let i = 0; i res[j].second && res[i].first == res[j].first){` `                ``let temp = res[j];` `                ``res[j] = res[i];` `                ``res[i] = temp;` `            ``}` `        ``}` `    ``}` `}` `console.log(``"\n"``);` `for``(let i = 0; i < res.length; i++){` `    ``for``(let j = 0; j < res[i].first; j++){` `        ``console.log(res[i].second + ``" "``);` `    ``}` `}`   `// this code is contributed by Yash Agarwal(yashagarwal2852002)`

Output

`8 8 8 2 2 5 5 -1 6 9999999 `

Time Complexity: O(n^2) I.e it take O(n) for getting the frequency sorted vector but for sorting in decreasing frequency if 2 numbers have the same frequency then print the one which came first we use bubble sort so it take O(n^2).
Auxiliary Space: O(n),for vector.

My Personal Notes arrow_drop_up