692. 前K个高频单词 - 力扣（LeetCode）
给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
示例 1：
输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
输出: ["i", "love"]
解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
注意，按字母顺序 "i" 在 "love" 之前。我们可以先把 words 当中的单词按照 pair<string,int>的方式放到 一个 map 当中去，然后使用 sort（）函数对 map 当中的 int （词频）进行排序，再把 排好序的 string ，放到一个 string vector 当中返回。
但是 sort（）函数支持的是 随机迭代器，而 map 是双向迭代器，所以 map 不能直接用于 sort（）函数，所以，我们想到把 map 当中的数据（key-value）放到一个 vector<pair<string,int>>当中去，因为 vector 的迭代器是随机迭代器，所以能使用 sort（）函数。
但是，如果我们想要 使用 pair对象当中的 int （词频）来排序的话，在 sort（）当中是支持仿函数的设定的，在 sort（）的第三个参数，就是仿函数，所以，我们需要自己实现一个 int 比较的仿函数：
class Greater
{
bool operator()(const int& x, const int& y)
{
return x > y;
}
};然后在调用 sort（）函数的时候调用这个 Greater的匿名对象就行了：
// 因为map 的迭代器是双向迭代器，不能用sort（），sort（）需要随机迭代器
vector<pair<string, int>> sortv(StringMap.begin(), StringMap.end());
sort(sortv.begin(), sortv.end(), greater());注意，这里给仿函数的形式是给 greater（），匿名对象的形式，因为 sort（）函数是以参数列表的形式接收 这个 仿函数（其实就是一个类），所以要接受一个对象。
而在模版参数当中接收的仿函数，接收的是类型，所以是以 greater<T> 这样的形式给的，如下所示：
当上述工作都完成之后，我们发现，我们输出的结果有误：
由上述结果可知，并不是完全无序的，而是 一组一组 的无序。通过观察发现，是sort（）函数的问题，sort（）函数的底层是使用快排来实现的，快排是不稳定的排序，所谓不稳定就是，同一个值，应该按照原本在数组当中存储的顺序来进行排序。这才是稳定的，但是 快排是不稳定的。
所以才出现了上述的输出错误。
其实在库当中，sort（）函数有一个 优化函数 ：stable_sort（），这个就是 稳定的 快排。
完整代码：
class Solution {
public:
// 用于比较 int（词频）的仿函数
// 可以使用 class，但是 class 当中成员不加 权限修饰符默认是 private
// struct 默认是 public 的
struct Greater
{
bool operator()(const pair<string, int>& x, const pair<string, int>& y)
{
return x.second > y.second;
}
};
// 主函数
vector<string> topKFrequent(vector<string>& words, int k) {
map<string, int> StringMap;
for(auto e : words)
{
StringMap[e]++;
}
// 因为map 的迭代器是双向迭代器，不能用sort（），sort（）需要随机迭代器
vector<pair<string, int>> sortv(StringMap.begin(), StringMap.end());
stable_sort(sortv.begin(), sortv.end(), Greater());
vector<string> retvector;
for(int i = 0;i < k;i++)
{
retvector.push_back(sortv[i].first);
}
return retvector;
}
};当然，使用 sort（）函数也可以解决，sort（）函数不稳定，我们在 仿函数比较规则当中控制就可以了（控制，当词频相同时候，string排序当中小的在前）：
class Solution {
public:
// 用于比较 int（词频）的仿函数
// 可以使用 class，但是 class 当中成员不加 权限修饰符默认是 private
// struct 默认是 public 的
struct Greater
{
bool operator()(const pair<string, int>& x, const pair<string, int>& y)
{
// 控制，当词频相同时候，string排序当中小的在前
return x.second > y.second || (x.second == y.second && x.first < y.first);
}
};
// 主函数
vector<string> topKFrequent(vector<string>& words, int k) {
map<string, int> StringMap;
for(auto e : words)
{
StringMap[e]++;
}
// 因为map 的迭代器是双向迭代器，不能用sort（），sort（）需要随机迭代器
vector<pair<string, int>> sortv(StringMap.begin(), StringMap.end());
sort(sortv.begin(), sortv.end(), Greater());
vector<string> retvector;
for(int i = 0;i < k;i++)
{
retvector.push_back(sortv[i].first);
}
return retvector;
}
};其实不使用 sort（）之类的排序函数也是可以实现的，map 本身在输出的时候就有排序的效果，我们可以先用map 按string 来排序（string作为key），再用 int（词频）来排序就可以实现了（int 作为 key）。
但是注意，我们要的结果是降序的前 k 个，但是 map 默认是 升序的，如果 默认升序的后 k 个话，string 排序是反的。
其实，map 还有一个模版参数，可以控制升序和降序：
他默认是 less（）仿函数，我们传入一个库当中的 greater（）仿函数就可以了：
完整代码实现：
class Solution {
public:
// 主函数
vector<string> topKFrequent(vector<string>& words, int k) {
// 排序string
map<string, int> StringMap;
for(auto e : words)
{
StringMap[e]++;
}
// 排序 int（词频）
multimap<int, string , greater<int>> intMap;
for(auto& e : StringMap)
{
intMap.insert(make_pair(e.second, e.first));
}
vector<string> retvector;
auto it = intMap.begin();
while(k--)
{
retvector.push_back(it->second);
it++;
}
return retvector;
}
};还可以使用 set 来实现，也是写仿函数按照 出现 频率去比，当出现频率相同，手动判断，然后进行处理（再去按照字典排）。
代码实现：
class Solution {
public:
class Compare
{
public:
// 在set中进行排序时的比较规则
bool operator()(const pair<string, int>& left, const
pair<string, int>& right)
{
return left.second > right.second;
}
};
vector<string> topKFrequent(vector<string>& words, int k)
{
// 用<单词，单词出现次数>构建键值对，然后将vector中的单词放进去，统计每
//个单词出现的次数
map<string, int> m;
for (size_t i = 0; i < words.size(); ++i)
++(m[words[i]]);
// 将单词按照其出现次数进行排序，出现相同次数的单词集中在一块
multiset<pair<string, int>, Compare> ms(m.begin(), m.end());
// 将相同次数的单词放在set中，然后再放到vector中
set<string> s;
size_t count = 0; // 统计相同次数单词的个数
size_t leftCount = k;
vector<string> ret;
for (auto& e : ms)
{
if (!s.empty())
{
// 相同次数的单词已经全部放到set中
if (count != e.second)
{
if (s.size() < leftCount)
{
ret.insert(ret.end(), s.begin(), s.end());
leftCount -= s.size();
s.clear();
}
else
{
break;
}
}
}
count = e.second;
s.insert(e.first);
}
}
}
