1 sort()使用自定义比较器

sort使用方法
头文件 #include
sort函数有三个参数：
sort(first,last,cmp);
其中，first是元素的起始地址，last是结束地址，cmp是排序的方式。对[first，last)（一定要注意这里的区间是左闭又开）区间内数据根据cmp的方式进行排序。也可以不写第三个参数，此时按默认排序，从小到大进行排序。

sort() 中的比较函数 compare 要声明为静态成员函数或全局函数，不能作为普通成员函数，否则会报错。

cmpChar实现功能：大写字母大于小写字母，小写字母按 a-z 升序，大写字母按 A-Z 升序

1.1 在类内部定义比较器 – 声明为静态成员函数

class Solution {
public:void CharacterSort(const vector<char> e_char){cout << "before:" << endl;for (auto i : e_char) {cout << i;}cout << endl;std::sort(e_char.begin(), e_char.end(), cmpChar);cout << "after:" << endl;for (auto i : e_char) {cout << i;}cout << endl;}private:static bool cmpChar(const char &a, const char &b){if (a <= 'Z' && b >= 'a')return false;else if (b <= 'Z' && a >= 'a')return true;elsereturn a < b;}};

输入：
vector e_char = {‘C’,‘B’,‘A’,‘c’,‘b’,‘a’};
输出：
before:
CBAcba
after:
abcABC

1.2 在函数内部定义比较器 – lamda表达式

class Solution {
public:void CharacterSort(const vector<char> e_char){cout << "before:" << endl;for (auto i : e_char) {cout << i;}cout << endl;auto cmpChar = [](const char &a, const char &b) {if (a <= 'Z' && b >= 'a')return false;else if (b <= 'Z' && a >= 'a')return true;elsereturn a < b;};std::sort(e_char.begin(), e_char.end(), cmpChar);cout << "after:" << endl;for (auto i : e_char) {cout << i;}cout << endl;}

1.3 全局函数比较器

using namespace std;bool cmpChar(const char &a, const char &b){if (a <= 'Z' && b >= 'a')return false;else if (b <= 'Z' && a >= 'a')return true;elsereturn a < b;}class Solution {
public:void CharacterSort(const vector<char> e_char){cout << "before:" << endl;for (auto i : e_char) {cout << i;}cout << endl;std::sort(e_char.begin(), e_char.end(), cmpChar);cout << "after:" << endl;for (auto i : e_char) {cout << i;}cout << endl;}

2 重载运算符<

例子：按年月日升序排序。

2.1 在结构体中重载运算符<

#include <algorithm>
#include <iostream>
#include <vector>using namespace std;struct date {int year;int month;int day;//在结构体中重载运算符<bool operator<(const date &a) const{// 重载<符号来比较日期的大小if (year == a.year) {if (month == a.month) {return day < a.day;} else {return month < a.month;}} else {return year < a.year;}}
};
// 在结构体外部重载运算符<
/*
bool operator<(const date &a, const date &b)
{// 重载<符号来比较日期的大小if (a.year == b.year) {if (a.month == b.month) {return a.day < b.day;} else {return a.month < b.month;}} else {return a.year < b.year;}
}
*/int main()
{cout << "Hello Word!\n";vector<date> exam;exam.push_back({1997, 8, 19});exam.push_back({1990, 1, 1});exam.push_back({1997, 9, 30});exam.push_back({1990, 1, 20});cout << "before:";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}sort(exam.begin(), exam.end());cout << "\nafter:";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}return 0;};

输出：

这里一定要注意一下：

参数类型如果是自定义类型，比如自己定义的结构体，类，尽管sort函数默认是从小到大排列，但是这里必须要重载比较运算符“<”!!!

2.2 在类中重载运算符<

#include <algorithm>
#include <iostream>
#include <vector>using namespace std;class date {
public:int year;int month;int day;// 在类内部重载运算符<bool operator<(const date &a){// 重载<符号来比较日期的大小if (year == a.year) {if (month == a.month) {return day < a.day;} else {return month < a.month;}} else {return year < a.year;}}
};
// 在类外部重载运算符<
/*
bool operator<(const date &a, const date &b)
{// 重载<符号来比较日期的大小if (b.year == a.year) {if (b.month == a.month) {return a.day < b.day;} else {return a.month < b.month;}} else {return a.year < b.year;}
}
*/
int main()
{cout << "Hello Word!\n";vector<date> exam;exam.push_back({1997, 8, 19});exam.push_back({1990, 1, 1});exam.push_back({1997, 9, 30});exam.push_back({1990, 1, 20});cout << "before:";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}sort(exam.begin(), exam.end());cout << "\nafter: ";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}return 0;
};

3 重写仿函数bool operator()

sort函数的默认比较函数std:less和std::greater，内部实现就是重载了运算符()。

int test[10] = {4, 1, 3, 7, 5, 8, 2, 9, 6, 10};
// 注意这里创建了greater对象，sort函数调用greater对象的()运算符重载方法
sort(test, test + 10, greater<int>());

这里首先调用的是greater类的默认构造方法，返回一个对象并传递给sort函数。sort函数内部调用对象(a,b)时调用的是对象的运算符()重载方法来进行比较。

这里重载了()运算符其实是构造了一个“伪函数”，也就是可以把类的对象作为函数来使用。

模仿greater和less模板类的定义，我们也可以自己定义比较器类:

#include <algorithm>
#include <iostream>
#include <vector>using namespace std;class date {
public:int year;int month;int day;
};struct MyLess  // 自定义比较器类
{bool operator()(const date &a, const date &b) const{if (a.year == b.year) {if (a.month == b.month) {return a.day < b.day;} else {return a.month < b.month;}} else {return a.year < b.year;}}
};int main()
{cout << "Hello Word!\n";vector<date> exam;exam.push_back({1997, 8, 19});exam.push_back({1990, 1, 1});exam.push_back({1997, 9, 30});exam.push_back({1990, 1, 20});cout << "before:";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}sort(exam.begin(), exam.end(), MyLess());cout << "\nafter: ";for (auto e : exam) {cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";}return 0;
};

4 使用pair排序

头文件：

#include <utility>  #pair头文件

定义：

pair<string,int> p; 
//① 将类型定义写在前面，后面用小括号内两个元素的方式。
pair<string,int>("haha",5)
//② 使用自带的 make_pair 函数。
make_pair("haha",5)

pair<typeName1,typeName2> name，可以是任意基本数据类型或容器。

pari的排序规则默认先比较第一个元素，第一个相等比较第二个。

#include <algorithm>
#include <iostream>
#include <vector>
#include <utility>using namespace std;int main()
{cout << "Hello Word!\n";std::vector<std::pair<int, std::pair<int, int>>> vec;vec.push_back(std::make_pair(1997, std::make_pair(8, 19)));vec.push_back(std::make_pair(1990, std::make_pair(1, 11)));vec.push_back(std::make_pair(1997, std::make_pair(9, 30)));vec.push_back(std::make_pair(1990, std::make_pair(1, 30)));cout << "\nbefore: ";for (auto e : vec) {std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";}cout << "\nless:   ";std::sort(vec.begin(), vec.end());for (auto e : vec) {std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";}cout << "\ngreater:";std::sort(vec.begin(), vec.end(), greater<std::pair<int, std::pair<int, int>>>());for (auto e : vec) {std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";}cout << std::endl;return 0;
};

5 priority_queue自定义排序规则

1. 头文件

#include <queue>

2. 定义

priority_queue<int> a;  //对于基础类型 默认是大顶堆
priority_queue<int, vector<int>, less<int> > a;  // 等同于priority_queue<int> a 
priority_queue<int, vector<int>, greater<int> > c;  //这样就是小顶堆

priority_queue<Type, Container, Functional>
Type为数据类型； Container为保存数据的容器（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list，STL里面默认用的是vector）；Functional为元素比较方式。
如果不写后两个参数，那么容器默认用的是vector，比较方式默认用operator<，也就是优先队列是大顶堆，队头元素最大。
当需要用自定义的数据类型时才需要传入这三个参数；

优先队列具有队列的所有特性，包括基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。

3 自定义排序规则
priority_queue使用自定义的数据类型，同时也要实现自定义排序规则，有2种方式：

1. 重载运算符<
2. 重写仿函数
   priority_queue自定义排序规则，返回true要交换位置，这与前面提到的几种排序返回true不一样，容易记错。

#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>using namespace std;struct date {int year;int month;int day;// 重载运算符<bool operator<(const date &a) const{// 重载<符号来比较日期的大小,返回true交换位置if (year == a.year) {if (month == a.month) {return day < a.day;} else {return month < a.month;}} else {return year < a.year;}}
};struct myCompare  // 重写仿函数,返回true交换位置
{bool operator()(const date &a, const date &b) const{if (a.year == b.year) {if (a.month == b.month) {return a.day < b.day;} else {return a.month < b.month;}} else {return a.year < b.year;}}
};int main()
{cout << "Hello Word!\n";priority_queue<date> vec_1;vec_1.push({1997, 2, 22});vec_1.push({1990, 10, 9});vec_1.push({1997, 2, 5});vec_1.push({1990, 8, 9});priority_queue<date, vector<date>, myCompare> vec_2;vec_2.push({2007, 2, 22});vec_2.push({2000, 10, 9});vec_2.push({2007, 2, 5});vec_2.push({2000, 8, 9});cout << "\noperator< : ";while (!vec_1.empty()) {std::cout << vec_1.top().year << ","<<vec_1.top().month<< ","<<vec_1.top().day<< ";";vec_1.pop();}cout << "\noperator(): ";while (!vec_2.empty()) {std::cout << vec_2.top().year << ","<<vec_2.top().month<< ","<<vec_2.top().day<< ";";vec_2.pop();}cout << std::endl;return 0;
};

6 关于priority_queue中存储pair类型的思考

当priority_queue不指定排序方式是默认是大根堆（降序），pair默认std::less（升序），但如果priority_queue存储的是pair类型的时候呢？
先说结论：priority_queue<pair<int, int>> myqueue，排序结果为降序.

int main()
{cout << "Hello Word!\n";priority_queue<pair<int, int>> myqueue;//若插入数据类型的构造函数接受多个参数，push只接受该类型的实例，emplace不仅能接受该类型的实例，还能接受该类型构造函数的参数。myqueue.push({1990, 7});myqueue.emplace(1997, 7);myqueue.emplace(2000, 8);myqueue.emplace(2000, 9);myqueue.emplace(1000, 7);while (!myqueue.empty()) {cout << myqueue.top().first << " " << myqueue.top().second << endl;myqueue.pop();}
return 0;
};

有的文章提到优先队列priority_queue中使用pair，个人觉得使用一种就行，priority_queue结合pair有什么优势欢迎评论区留言。