Print the elements of an array in the decreasing frequency if 2 numbers have 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.

- We insert all elements and their counts into a hash. This step takes O(n) time where n is number of elements.
- We copy 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.
- For maintaining the order of elements if the frequency is same, we use another hash which has the key as elements of the array and value as the index. If the frequency is same for two elements then sort elements according to the index.

The C++ implementation is given below.

`// Sort elements by frequency. If two elements have same ` `// count, then put the elements that appears first ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Map m2 keeps track of indexes of elements in array ` `unordered_map<` `int` `, ` `int` `> m2; ` ` ` `// 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` `m2[a.first] < m2[b.first]; ` ` ` ` ` `return` `a.second > b.second; ` `} ` ` ` `// function to sort elements by frequency ` `void` `sortByFreq(` `int` `a[], ` `int` `n) ` `{ ` ` ` `unordered_map<` `int` `, ` `int` `> m; ` ` ` `vector<pair<` `int` `, ` `int` `> > v; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; ++i) { ` ` ` ` ` `// Map m is used to keep track of count ` ` ` `// of elements in array ` ` ` `m[a[i]]++; ` ` ` ` ` `// Update the value of map m2 only once ` ` ` `if` `(m2[a[i]] == 0) ` ` ` `m2[a[i]] = i + 1; ` ` ` `} ` ` ` ` ` `// 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) ` ` ` `for` `(` `int` `j = 0; j < v[i].second; ++j) ` ` ` `cout << v[i].first << ` `" "` `; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `a[] = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` ` ` `sortByFreq(a, n); ` ` ` ` ` `return` `0; ` `} ` |

Output:

8 8 8 2 2 5 5 6 -1 9999999

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

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## leave a comment

## 0 Comments