按频率排序元素 |设置 4（使用哈希的有效方法）

如果 2 个数字具有相同的频率，则以递减的频率打印数组的元素，然后打印第一个。
例子：

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}
 

我们在以下帖子中讨论了不同的方法：
按频率排序元素 |设置 1
按频率排序元素 | 2套
按频率排序数组元素 |设置 3（使用 STL）
以上所有方法都在 O(n Log n) 时间内工作，其中 n 是元素总数。在这篇文章中，讨论了一种在O(n + m Log m)时间内工作的新方法，其中 n 是元素总数，m 是不同元素的总数。
这个想法是使用散列。

1. 我们将所有元素及其计数插入到一个散列中。这一步需要 O(n) 时间，其中 n 是元素数。
2. 我们将 hash 的内容复制到一个数组（或向量）中，并按计数对它们进行排序。这一步需要 O(m Log m) 时间，其中 m 是不同元素的总数。
3. 为了在频率相同的情况下保持元素的顺序，我们使用另一个散列，它以键作为数组的元素，以值作为索引。如果两个元素的频率相同，则根据索引对元素进行排序。

下图是上述方法的试运行：

我们不需要声明另一个映射 m2，因为它没有为问题提供正确的预期结果。

相反，我们只需要检查在 sortByVal函数作为参数发送的对的第一个值。

下面是上述方法的实现：

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& a,
                      const pair& 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
vectorsortByFreq(int a[], int n)
{
 
   vectorres;
 
   unordered_map 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]);
   vectorres;
   res = sortByFreq(a, n);
 
   for(int i = 0;i < res.size(); i++)
         cout<

---

输出：

8 8 8 2 2 5 5 6 -1 9999999 

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。