Prerequisite:

先決條件：

• Hashing data structure

  散列數據結構

• How to write user-defined comparator for priority queue STL in C++?

  如何在C ++中為優先級隊列STL編寫用戶定義的比較器？

• How to sort a map based on values instead of value?

  如何根據值而不是值對地圖排序？

Problem statement:

問題陳述：

Sort an array based on frequencies. The element having maximum frequency will come first. If two elements have the same frequency then the element coming first will appear first in the sorted array two.

根據頻率對數組排序。 具有最大頻率的元素將排在最前面。 如果兩個元素具有相同的頻率，則最先出現的元素將首先出現在排序數組2中。

Example:

例：

Input array:
[1, 2, 3, 2, 3, 2, 1]After sorting frequency wise:
[2, 2, 2, 1, 1, 3, 3]2 has the maximum frequency 
thus, it came first and since 1 and 3 have the same frequency, 
so, 1 came first preserving the order in the input array.

Solution:

解：

The idea is to create a hash table first which will store the frequency of unique elements. That can be created like below:

這個想法是首先創建一個哈希表，它將存儲唯一元素的頻率。 可以如下創建：

Hash function, h(x)=x but instead of storing key we will store the count

哈希函數h(x)= x，但是我們將存儲計數而不是存儲密鑰

Initially, hash table is empty.

最初，哈希表為空。

For each key in input array,
Hash[key]++
End for

If we create the hash table from the above input array, it will be,

如果我們根據上面的輸入數組創建哈希表，它將是

Key	Frequency
1	2
2	3
3	2

So now we need to sort the map based on the value instead of the key, but for the same frequencies, we need to preserve the key order(it’s order not key itself).

因此，現在我們需要根據值而不是鍵對映射進行排序，但是對于相同的頻率，我們需要保留鍵順序(該順序不是鍵本身)。

To preserve the key order we require another hash table that would store the first position of the key. We will store that like below:

為了保留鍵順序，我們需要另一個哈希表，該哈希表將存儲鍵的第一個位置。 我們將像下面這樣存儲：

Say this hash table is named first_occurrence

假設此哈希表名為first_occurrence

For each key in input array,
If first_occurence[key]==0: //not assigned
first_occurence[key]=key index+1
End for

So after processing the input the hash table first_occurrence would be:

因此，在處理輸入后，哈希表first_occurrence將是：

Key	First occurrence
1	1(0+1)
2	2(1+1
3	3(2+1)

So now rest of the task is to sort the hash table based on the map and based on first_occurrence hash table.

因此，現在剩下的任務是根據地圖和基于first_occurrence哈希表對哈希表進行排序。

We will use the priority queue to sort this map based on our defined comparator where we will implement logic to sort by frequency value and first_occurrence hash table.

我們將使用優先級隊列根據定義的比較器對此映射表進行排序，在該比較器中，我們將實現按頻率值和first_occurrence哈希表排序的邏輯。

How to pass this in the comparator is our main challenge or area of our discussion?

如何在比較器中傳遞這一點是我們的主要挑戰還是我們討論的領域？

You can observe a thing that we have designed a class for this problem and kept the first_occurrence hash table as a data member, not any local member to a function. Thing is not the thing I do in general. So, there must be something, that made me design a class and bring the OOP concept within it. This is because I need to feed the first_occurrence hash table into the comparator and the comparator is a lambda function. Like below,

您會發現，我們已經為此問題設計了一個類，并將first_occurrence哈希表保留為數據成員，而不是函數的任何本地成員。 總的來說，這不是我要做的事情。 因此，必須有某種東西使我設計了一個類并將OOP概念引入其中。 這是因為我需要將first_occurrence哈希表提供給比較器，并且比較器是lambda函數。 像下面一樣

auto comp=[](pair<int,int> a, pair<int,int> b){
//function body
}
But this time if you notice the implementation, we have 
auto comp=[this](pair<int,int> a, pair<int,int> b){
//function body
}

This helps you to pass the data members to the lambda function or it's known as capturing of the lambda function.

這可以幫助您將數據成員傳遞給lambda函數，或者稱為捕獲lambda函數 。

That's why we designed the class and made first_occurrence as data members to feed into the lambda function. Now we can perform our logic similarly as we do in comparators.

這就是為什么我們設計類并讓first_occurrence作為數據成員饋入lambda函數的原因。 現在，我們可以像在比較器中一樣執行邏輯。

The lambda comparator would be like below which will give us a sorted map based on our requirement via the priority_queue.

Lambda比較器如下所示，它將根據優先級通過priority_queue為我們提供排序的映射。

auto comp=[this](pair<int,int> a, pair<int,int> b){          
if(a.second<b.second)
return true;
else if(a.second>b.second)
return false;
else{
if(first_occurence[a.first]<first_occurence[b.first])
return false;
else
return true;
}
};

So after pushing all pairs(a map element is pair, <key, element>) we will have our priority queue as,

因此，在推送所有對之后(一個地圖元素是pair，<key，element>)，我們將擁有優先級隊列，

Key	Frequency
2	3
1	2
3	2

Now, pop each element from the priority queue and append the key as many times as the frequency,

現在，從優先級隊列中彈出每個元素，并按頻率添加鍵多次，

So at iteration 1
We will pop <2,3>
So vector will be 2 2 2
So at iteration 2
We will pop <1,2>
So vector will be 2 2 2 1 1
So at iteration 3
We will pop <3,2>
So vector will be 2 2 2 1 1 3 3
Queue Is empty
So our sorted array based on frequency is
2 2 2 1 1 3 3

C++ implementation:

C ++實現：

#include <bits/stdc++.h>
using namespace std;
class Includehelp {
public:
unordered_map<int, int> first_occurence;
void print(vector<int> arr)
{
for (auto i : arr) {
cout << i << " ";
}
cout << endl;
}
vector<int> sort_by_frequency(vector<int> arr)
{
//create the hashmap
unordered_map<int, int> mymap;
for (int i = 0; i < arr.size(); i++) {
mymap[arr[i]]++;
if (first_occurence[arr[i]] == 0)
first_occurence[arr[i]] = i + 1;
}
//now to sort based on frequency lets use priority queue
//comparator of priority queue using lambda function
auto comp = [this](pair<int, int> a, pair<int, int> b) {
if (a.second < b.second)
return true;
else if (a.second > b.second)
return false;
else {
if (first_occurence[a.first] < first_occurence[b.first])
return false;
else
return true;
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, decltype(comp)> pq(comp);
for (auto& ij : mymap) {
pq.push(ij);
}
//sorted outcome
vector<int> result;
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
int no = p.first;
int freq = p.second;
for (int i = 0; i < freq; i++)
result.push_back(no);
}
return result;
}
};
int main()
{
int n;
cout << "Enter number of elements\n";
cin >> n;
vector<int> arr(n, 0);
cout << "Enter the elements\n";
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
Includehelp* obj = new Includehelp();
arr = obj->sort_by_frequency(arr);
cout << "Printing after sorting by frequency\n";
obj->print(arr);
return 0;
}

Output:

輸出：

Enter number of elements
8
Enter the elements
1 2 3 1 2 3 4 5
Printing after sorting by frequency
1 1 2 2 3 3 4 5 

翻譯自: https://www.includehelp.com/data-structure-tutorial/sort-elements-by-frequency.aspx