leetcode 大顶推 小顶堆 优先队列实现前K大/小 （347、692、451、973、373）
347 前K个高频元素
题目描述： 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
思路： 用map统计每个元素出现的次数，map的数据格式相当于pair。建立小顶堆，保持优先队列的大小为k，当优先队列已经装满k个元素后，再向队列中push数据时，如果大于堆顶数据，则压入队列，并将最上面的数据pop出去(即pop出当前队列中最小的元素)；如果小于，则不进行入队列出队列的操作。
具体的思路及时间复杂度见代码中注释。
class Solution {
public:
// 堆排序 时间复杂度O(nlogk) 统计频率O(n) 遍历map放入优先队列中O(nlogk) 放入一个元素为O(logn)
vector topKFrequent(vector& nums, int k) {
unordered_map cnt;
for(int i = 0; i < nums.size(); i++)
cnt[nums[i]]++;
priority_queue, vector>, greater> > Q; // 记住喔！！ greater可以实现pop出的元素为最小值元素 该参数默认为less，实现的是pop出最大值元素
for(auto &p : cnt) {
Q.push(make_pair(p.second, p.first));
if(Q.size() > k)
Q.pop();
}
vector ans;
while(!Q.empty()) {
ans.push_back(Q.top().second);
Q.pop();
}
return ans;
}
};
692 前K个高频单词
题目描述： 给一非空的单词列表，返回前 k 个出现次数最多的单词。返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序。
思路： 和347题目的思路相同。先统计出现频率，再利用小顶堆排序。注意本题目有要求单词的排序顺序，需要自己定义优先队列的排序规则。在最后需要reverse()操作。
class Solution {
public:
struct cmp {
bool operator () (pair a, pair b) {
if(a.first != b.first)
return a.first > b.first;
return a.second < b.second; // 题目要求字母顺序，即a应该在b前面，a是小于b的， a应该被放在堆底。
}
};
vector topKFrequent(vector& words, int k) {
unordered_map cnt;
for(int i = 0; i < words.size(); i++)
cnt[words[i]] ++;
priority_queue, vector>, cmp> Q;
for(auto &p : cnt) {
Q.push(make_pair(p.second, p.first));
if(Q.size() > k)
Q.pop();
}
vector ans;
while(!Q.empty()) {
cout<< Q.top().first<<" "<< Q.top().second< 451 根据字符出现频率排序
题目描述： 给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
实例： 输入:“tree”，输出:“eert”/“eetr”。
思路1： 堆排序。先统计出现频率，再利用优先队列实现堆排序。最后从优先队列取出字符时，注意要取出对应的出现频率次。时间复杂度O(nlogn)。
思路2： 桶排序。具体思路见代码注释。注意字符串中不只包含字母，统计出现频率时，应该开一个大小为128的向量数组。
// 思路1：
class Solution {
public:
// 堆排序 优先队列
string frequencySort(string s) {
unordered_map mp;
for(int i = 0; i < s.size(); i++)
mp[s[i]]++;
priority_queue> Q;
for(auto &p : mp)
Q.push(make_pair(p.second, p.first));
string ans = "";
while(!Q.empty()) {
for(int i = 0; i < Q.top().first; i++)
ans += Q.top().second;
Q.pop();
}
return ans;
}
};
// 思路2：
class Solution {
public:
// 桶排序
string frequencySort(string s) {
if(s.size() == 0)
return "";
vector cnt(128, 0); // char类型为一个字节，一个字节有八位。ascii编码一共有128个
for(int i = 0; i < s.size(); i++) // 统计出现频率
cnt[s[i]]++;
vector> buckets(s.size() + 1); //建桶
for(int i = 0; i < cnt.size(); i++)
buckets[cnt[i]].push_back(i);
string ans = "";
for(int i = buckets.size() - 1; i >= 1; i--)
for(int j = 0; j < buckets[i].size(); j++)
ans.append(i, buckets[i][j]); // 按要求顺序遍历各个桶内元素
return ans;
}
};
973 最接近原点的K个点
思路描述： 我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。（这里，平面上两点之间的距离是欧几里德距离。）你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。
思路： 堆排序。根据题目要求，找出和原点欧几里得距离最小的K个点。维护一个K个值的大顶堆。同347题。注意优先队列的排序方式。
class Solution {
public:
struct node {
int x;
int y;
int dis;
friend bool operator < (node a, node b) { // 不在比较函数中进行运算
return a.dis < b.dis;
}
};
vector> kClosest(vector>& points, int K) {
priority_queue Q;
for(int i = 0; i < points.size(); i++) {
Q.push(node{points[i][0], points[i][1], points[i][0] * points[i][0] + points[i][1] * points[i][1]});
if(Q.size() > K) {
Q.pop();
}
}
vector> ans;
vector tmp(2, 0);
while(!Q.empty()) {
tmp[0] = Q.top().x;
tmp[1] = Q.top().y;
ans.push_back(tmp);
Q.pop();
}
return ans;
}
};
373 查找和最小的K对数字
题目描述： 给定两个以升序排列的整形数组 nums1 和 nums2, 以及一个整数 k。定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2。找到和最小的 k 对数字 (u1,v1), (u2,v2) … (uk,vk)。
思路1： 堆排序，思路同973题。
思路2： 二分。二分出前k小的组合的最大值，再根据二份出来的sum值，将小于sum的组合装进答案中。注意边界值的数字对可能有多个，导致有大于K对数字符合最小的K对数字的要求，在二分时要注意更新sum值的位置。
// 思路1
class Solution {
public:
struct node {
int sum;
int first;
int second;
friend bool operator < (const node& a, const node& b) {
return a.sum < b.sum;
}
};
vector> kSmallestPairs(vector& nums1, vector& nums2, int k) {
priority_queue Q;
for(int i = 0 ; i < nums1.size(); i++) {
for(int j = 0; j < nums2.size(); j++) {
if(!Q.size() == k && (nums1[i] + nums2[j] >= Q.top().sum))
break;
Q.push(node{nums1[i] + nums2[j], nums1[i], nums2[j]});
if(Q.size() > k)
Q.pop();
}
}
vector> ans;
vector tmp(2, 0);
while(!Q.empty()) {
node tmpNode = Q.top();
tmp[0] = tmpNode.first;
tmp[1] = tmpNode.second;
ans.push_back(tmp);
Q.pop();
}
reverse(ans.begin(), ans.end());
return ans;
}
};
// 思路2
class Solution {
public:
// 二分
int getNum(vector& nums1, vector& nums2, int k, int mid, int n1, int n2) {
int num = 0;
for(int i = 0; i < n1 && num <= k; i++) {
for(int j = 0; j < n2 && num <= k; j++) {
if(nums1[i] + nums2[j] <= mid)
num++;
else
break;
}
}
return num;
}
vector> kSmallestPairs(vector& nums1, vector& nums2, int k) {
vector> ans;
int n1= nums1.size(), n2 = nums2.size();
if(n1 == 0 || n2 == 0)
return ans;
// 更新k值
k = min(k, n1 * n2);
// 二分前k小的组合的最大值 时间复杂度为k * log(high)
int low = nums1[0] + nums2[0], high = nums1[n1 - 1] + nums2[n2 - 1], sum = 0;
while(low <= high) {
int mid = (low + high) / 2;
// cout<= k) {
high = mid - 1;
sum = mid;
}
else
low = mid + 1;
}
// cout<< sum < tmp;
tmp.push_back(nums1[i]);
tmp.push_back(nums2[j]);
ans.push_back(tmp);
}
else
break;
}
}
for(int i = 0; i < n1 && ans.size() < k; i++) {
for(int j = 0; j < n2 && ans.size() < k; j++) {
if(nums1[i] + nums2[j] == sum) {
vector tmp;
tmp.push_back(nums1[i]);
tmp.push_back(nums2[j]);
ans.push_back(tmp);
}
else if(nums1[i] + nums2[j] > sum)
break;
}
}
return ans;
}
};