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.

- We insert all elements and their counts into a hash. This step takes O(n) time where n is number of elements.
- 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.
- 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 <bits/stdc++.h>` `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<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]]++; ` ` ` `}` ` ` `// 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<<res[i]<<` `" "` `;` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

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

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

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Sort the given Matrix | Memory Efficient Approach
- What are Hash Functions and How to choose a good Hash Function?
- Sort elements by frequency | Set 5 (using Java Map)
- Maximum difference between frequency of two elements such that element having greater frequency is also greater
- Sort elements by frequency | Set 2
- Sort elements by frequency | Set 1
- Check if frequency of character in one string is a factor or multiple of frequency of same character in other string
- Maximum length prefix such that frequency of each character is atmost number of characters with minimum frequency
- Comparison among Bubble Sort, Selection Sort and Insertion Sort
- Graph representations using set and hash
- Minimum increment or decrement required to sort the array | Top-down Approach
- Sorting Array Elements By Frequency | Set 3 (Using STL)
- Sort an array of strings based on the frequency of good words in them
- Sort an array of Strings according frequency
- Sort a string according to the frequency of characters
- Trie memory optimization using hash map
- Sorting using trivial hash function
- String hashing using Polynomial rolling hash function
- Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
- Insertion sort to sort even and odd positioned elements in different orders