C++中优先队列，sort自定义比较方法

C++中优先队列，sort自定义比较方法

347. 前 K 个高频元素 - 力扣（LeetCode）

题目表述

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

分析

对于这种K个最大，或者K个最小的问题，一般使用优先队列来实现

首先用map记录下元素和对应的元素个数，之后将map元素放入队列中，并且限制队列大小，最后依次取出对应的数并放入vector中。

解题代码

class Solution {
public:
struct mycomparison1 {
    bool operator() (const pair<int, int>& lhs, const pair<int, int>& rhs) {
        return lhs.second > rhs.second;
    }
};
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int > map;
        for (size_t i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison1> priQue;
        for (auto item = map.begin(); item != map.end(); item++) {
            priQue.push(*item);
            if (priQue.size() > k) {
                priQue.pop();
            }
        }
        vector<int> res;
        for (int i = 0; i < k; i++) {
            res.push_back(priQue.top().first);
            priQue.pop();
        }
        return res;
    }
};

知识点分析与拓展

1、优先队列

C++中优先队列为std::priority_queue, 对于这个模板类priority_queue，它是STL所提供的一个非常有效的容器。

作为队列的一个延伸，优先队列包含在头文件 <queue> 中。

// 总共三个参数，第一个是类型，这个不能省，相当于是模板参数
// 第二个是实现队列的容器，可以是vector或者list,但是不能是数组，默认是vector
// 第三个是自定义的比较器，默认是less,也就是默认是大顶堆，greater对应的是小顶堆
// 假如需要指定自己的比较器，那么需要将第二个容器也给指定
priority_queue<class Type,class Container,class Compare> 

数组从大到小排序

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
int findKthLargest(vector<int>& nums, int k);

int main() {
    vector<int> nums = {5,1,2,8,0};
    int res = findKthLargest(nums, 2);
    cout << res << endl;
}
int findKthLargest1(vector<int>& nums, int k) {
    sort(nums.begin(), nums.end(), greater<int>());
    return nums[k - 1];
}

int findKthLargest(vector<int>& nums, int k) {
    priority_queue<int, vector<int>, greater<>> queue;   // 这里定义的优先队列里面需要指定容器和比较器
    for (int i = 0; i < nums.size(); i++) {
        queue.push(nums[i]);
        if (queue.size() > k) {
            queue.pop();
        }
    }
    return queue.top();
}

pair对象的自定义比较

class Solution {
public:
    
    // 结构体方式
    struct mycomparison1 {    // 自定义比较器，并且重载()符号
        bool operator() (const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    
    // 自定义类方式
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    
    // 实际应用
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int > map;
        for (size_t i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }
        // 指定了类型，容器以及自定义比较器
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison1> priQue; 
        for (auto item = map.begin(); item != map.end(); item++) {
            priQue.push(*item);   // 注意这里利用auto之后，item是指针值，需要解引用
            if (priQue.size() > k) {
                priQue.pop();
            }
        }
        vector<int> res;
        for (int i = 0; i < k; i++) {
            res.push_back(priQue.top().first);
            priQue.pop();
        }
        return res;
    }
};

2、sort函数

sort函数被声明在<algorithm>头文件中，sort()函数可以对给定区间所有元素进行排序。

它有三个参数sort(begin, end, cmp)，其中begin为指向待sort()的数组的第一个元素的指针，end为指向待sort()的数组的最后一个元素的下一个位置的指针，cmp参数为排序准则，cmp参数可以不写，如果不写的话，默认从小到大进行排序。

cmp默认是less()，如果需要安装从大到小的顺序排序，则需要利用greater<>();

数组元素的自定义排序

#include<iostream>
#include<algorithm>
using namespace std;

bool cmp(int x,int y){ 
	return x % 10 > y % 10;    // 按照数的个位数大小来进行排序
}

int main(){
	int num[10] = {65,59,96,13,21,80,72,33,44,99};
	sort(num,num+10,cmp);
	for(int i=0;i<10;i++){
		cout<<num[i]<<" ";
	}//输出结果：59 99 96 65 44 13 33 72 21 80
	return 0;
}

结构体元素的自定义排序

自己实现比较函数，然后传入sort函数就OK了

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

struct Student{
	string name;
	int score;
	Student() {}
	Student(string n,int s):name(n),score(s) {}
};

bool cmp_score(Student x,Student y){    // 按照学生的分数，从高到低来进行排列
	return x.score > y.score;
}

int main(){
	Student stu[3];
	string n;
	int s;
	for(int i=0;i<3;i++){
		cin>>n>>s;
		stu[i] = Student(n,s);
	}
	
	sort(stu,stu+3,cmp_score);
	
	for(int i=0;i<3;i++){
		cout<<stu[i].name<<" "<<stu[i].score<<endl;
	}
	return 0;
}

3、map排序

在C++中，map有std::map, std::multimap, std::unordered_map三种形式，set对应也有三种，区别如下

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

map和multimap的区别在于multimap的一个key可以对应多个value，比如在电话簿中相同的人可以有两个以上电话号码，文件系统中可以将多个符号链接映射到相同的物理文件，或DNS服务器可以将几个URLs映射到相同的IP地址。

map和set是有序的，默认是按照key的大小来进行排序，默认为less，即从小到大

自定义key排序

#include <iostream>
#include <vector>
#include<algorithm>
#include <map>
#include <string>

using namespace std;

struct cmp {   // 自定义一个比较器，实现map按照key的长度从大到小来排序
    bool operator() (const string& lhs, const string& rhs) const{   // 注意这里需要声明为const
        return lhs.length() > rhs.length();
    }
};

// 按照value排序
// map的比较对象是key, 如果需要按照value的值来进行排序，可以先将map里面的对象给放到vector里面去，然后再利用sort方法排序
bool valueCmp(const pair<string, int>& lhs, const pair<string, int>& rhs) {  // sort按照第二个来进行排序
    return lhs.second < rhs.second;
}


int main() {

    map<string, int, cmp> mapStudent;  //关键是这句话
    mapStudent["LiMin"]=90;
    mapStudent["ZiLinMi"]=72;
    mapStudent["BoB"]=79;
    cout << "the first sorted by first key" << endl;
    
    vector<pair<string, int>> vec;
    for(auto item = mapStudent.begin(); item != mapStudent.end(); item++)
    {
        cout<< item->first << " " << item->second << endl;
        vec.push_back(*item);  // push 进去指针
    }

    cout << "sorted by second key" << endl;
    sort(vec.begin(), vec.end(), valueCmp);
    for (const auto &item: vec){
        cout << item.first << " " << item.second << endl;
    }
}