sort自定义排序

参考：
https://blog.csdn.net/weixin_41588502/article/details/86620305?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf

https://blog.csdn.net/v_xchen_v/article/details/76615270?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160208229619724836730206%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=160208229619724836730206&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_v2~rank_v25-2-76615270.pc_search_result_cache&utm_term=c%2B%2B%E4%B8%ADsort%E8%87%AA%E5%AE%9A%E4%B9%89%E6%8E%92%E5%BA%8F&spm=1018.2118.3001.4187

https://blog.csdn.net/ancientear/article/details/79590137?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-4.add_param_isCf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-4.add_param_isCf

例：大整数排序。

对N个长度最长可达到1000的数进行排序。

输入第一行为一个整数N，(1<=N<=100)。
接下来的N行每行有一个数，数的长度范围为1<=len<=1000。
每个数都是一个正数，并且保证不包含前缀零。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
bool cmp(string& s1, string& s2) {
    if (s1.size() < s2.size()) {
        return true;
    }
    else if (s1.size() == s2.size() && s1 < s2) {
        return true;
    }
    return false;
}
//别人的写法：
bool cmp(const string& s1, const string& s2) {
	if (s1.size() != s2.size()) {  
		return s1.size() < s2.size(); //如果长度不等，按长度大小升序排序
	}
	return s1 < s2; //若长度相等按字符串大小升序排序
}

int main() {
    int n;
    while (cin >> n) {
        vector<string> s(n);
        for (int i = 0; i < n; ++i) {
            cin >> s[i];
        }
        sort(s.begin(), s.end(),cmp);
        for (auto& x : s) {
            cout << x << endl;
        }
    }
}

2. 输入一个四行五列的矩阵，找出每列最大的两个数。按照样例输出的格式将每列最大的两个数输出，如果最大的两个数中的一个数在这一列中有多个相同的值，则行值取行值小的那一个。
   输出时要保留原矩阵的行列顺序，即在原矩阵中行值小的，在输出矩阵中的行值依然小。
   

struct node {
    int val; //元素值
    int idx;  //元素下标
};
bool cmp(node& n1, node& n2) {
    return n1.val < n2.val;  //按元素值排序
}
bool cmp1(node& n1, node& n2) {
    return n1.idx < n2.idx; //按下标排序
}
int main() {
    int a[4][5];
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 5; ++j) {
            cin >> a[i][j];
        }
    }
    vector<int> res(10);
    //对每一列元素先按元素值排序，再把最大的两个按下标排序
    for (int i = 0; i < 5; ++i) {
        node t[4];
        for (int j = 0; j < 4; ++j) {
            t[j].val = a[j][i];
            t[j].idx = j;
        }
        sort(t, t + 4, cmp);
        sort(t + 2, t + 4, cmp1);
        res[i] = t[2].val;
        res[i + 5] = t[3].val;
    }
    for (int i = 0; i < 10; ++i) {
        cout << res[i] << ' ';
        if (i == 4) cout << endl;
    }
}

3. 结构体排序

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

struct employees{
    int id;
    string name;
    int age;
    employees(){}
    employees(int id,string name,int age):id(id),name(name),age(age){}
};
bool cmp(employees& e1,employees& e2){
    if(e1.age<e2.age){
        return true;
    }
    else if(e1.age==e2.age && e1.id<e2.id){
        return true;
    }
    else if(e1.age==e2.age && e1.id==e2.id && e1.name<e2.name){
        return true;
    }
    else return false;
}
int main(){
    int n;
    cin>>n;
    employees *emp = new employees[n];
    for(int i=0;i<n;++i){
        cin >> emp[i].id >> emp[i].name >> emp[i].age;
    }
    sort(emp,emp+n,cmp);
    for(int i=0;i<min(3,n);++i){
        cout<<emp[i].id<<" "<<emp[i].name<<" "<<emp[i].age<<endl;
    }
}

之前学习的二维数组的排序和字符串的自定义排序：
https://blog.csdn.net/qq_40637903/article/details/108901739

lambda表达式

[]() { } ()

前k个高频词

class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        unordered_map<string, int> cnt;
        for (auto& word : words) {
            ++cnt[word];
        }
        vector<string> rec;
        for (auto& [key, value] : cnt) {
            rec.emplace_back(key);
        }
        sort(rec.begin(), rec.end(), [&](const string& a, const string& b) -> bool {
            return cnt[a] == cnt[b] ? a < b : cnt[a] > cnt[b];
        });
        rec.erase(rec.begin() + k, rec.end());
        return rec;
    }
};

class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        unordered_map<string, int> cnt;
        for (auto& word : words) {
            cnt[word]++;
        }
        auto cmp = [](const pair<string, int>& a, const pair<string, int>& b) {
            return a.second == b.second ? a.first < b.first : a.second > b.second;
        };
        priority_queue<pair<string, int>, vector<pair<string, int>>, decltype(cmp)> que(cmp);
        for (auto& it : cnt) {
            que.emplace(it);
            if (que.size() > k) {
                que.pop();
            }
        }
        vector<string> ret(k);
        for (int i = k - 1; i >= 0; i--) {
            ret[i] = que.top().first;
            que.pop();
        }
        return ret;
    }
};