目录
sort对 vector容器
sort对 vector<pair<int,int>>对组
sort对 结构体
结构体外部规定排序
结构体内部运算符重载
map容器的排序
map的键排序
map的值排序
sort对二维数组的排序
sort对 vector容器
sort()函数可以用于对vector容器进行排序。具体来说，sort()函数可以接受一个表示容器的迭代器范围作为参数，然后对该范围内的元素进行排序。在排序时，我们需要传入一个比较函数，用于告诉sort()函数如何比较元素。 下面是一个示例代码，演示如何使用sort()函数对vector容器进行排序：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
vector<int> nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
sort(nums.begin(), nums.end()); // 默认升序排序
for(auto num : nums) {
cout << num << " ";
}
cout << endl;
sort(nums.begin(), nums.end(), greater<int>()); // 降序排序
for(auto num : nums) {
cout << num << " ";
}
cout << endl;
return 0;
}输出结果为：
1 1 2 3 3 4 5 5 5 6 9
9 6 5 5 5 4 3 3 2 1 1 在上面的代码中，我们创建了一个名为nums的vector容器，并初始化了一些整数值。然后，我们先调用了一次sort()函数，对容器中的元素进行升序排序，并使用一个循环打印出排序后的结果。接着，我们又调用了一次sort()函数，并传入了一个比较函数greater<int>()，用于告诉sort()函数按照降序排序。最后，我们再次使用一个循环打印出排序后的结果。 需要注意的是，sort()函数会修改容器中的元素顺序，因此在排序前最好将容器备份一下，以免意外修改到原有数据。
sort对 vector<pair<int, int>>排序
要对vector<pair<int,int>>的第二个元素进行排序，可以使用sort()函数来实现。使用sort()函数需要传入三个参数，第一个参数是要排序的起始位置，第二个参数是要排序的结束位置，第三个参数是一个函数指针，用于指定排序的规则。 下面是一个示例代码，演示如何对vector<pair<int,int>>的第二个元素进行升序排序：
//对第二元素排序
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
int main() {
vector<pair<int, int>> v = {{1, 4}, {2, 2}, {3, 5}, {4, 1}, {5, 3}};
sort(v.begin(), v.end(), cmp);
for(auto p : v) {
cout << p.first << " " << p.second << endl;
}
return 0;
}输出结果：
4 1
2 2
5 3
1 4
3 5
在上面的代码中，我们定义了一个比较函数cmp()，用于指定排序规则。这个函数接受两个参数，都是pair<int,int>类型的引用。它会比较这两个pair的第二个元素，如果第一个pair的第二个元素小于第二个pair的第二个元素，就返回true，否则返回false。 然后，在main()函数中，我们创建了一个vector<pair<int,int>>类型的变量v，并初始化了一些值。然后，我们调用sort()函数对v进行排序。最后，我们使用一个循环打印出排序后的结果。
值得注意的是，如果是对第一个元素进行排序，则不需要cmp函数，因为sort默认对第一个元素排序
//对第一元素排序
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
//bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
// return a.second < b.second;
//}
int main() {
vector<pair<int, int>> v = { {1, 4}, {2, 2}, {3, 5}, {4, 1}, {5, 3} };
sort(v.begin(), v.end());
for (auto p : v) {
cout << p.first << " " << p.second << endl;
}
return 0;
}输出：
1 4
2 2
3 5
4 1
5 3
sort对 结构体
结构体外部规定排序
对结构体排序和对vector的排序类似，也是使用sort()函数来实现。不同之处在于，需要指定一个比较函数来告诉sort()函数如何比较结构体对象。 下面是一个示例代码，演示如何对一个包含多个字段的结构体进行排序：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct Person {
string name;
int age;
double salary;
};
bool cmpAge(const Person& p1, const Person& p2) {
return p1.age < p2.age; // 按照年龄升序排序
}
bool cmpSalary(const Person& p1, const Person& p2) {
return p1.salary > p2.salary; // 按照工资降序排序
}
int main() {
vector<Person> people = {
{"Alice", 25, 4000.0},
{"Bob", 30, 5000.0},
{"Charlie", 20, 3000.0},
{"David", 35, 6000.0},
};
sort(people.begin(), people.end(), cmpAge);
cout << "按照年龄升序排序：" << endl;
for(auto p : people) {
cout << p.name << " " << p.age << " " << p.salary << endl;
}
sort(people.begin(), people.end(), cmpSalary);
cout << "按照工资降序排序：" << endl;
for(auto p : people) {
cout << p.name << " " << p.age << " " << p.salary << endl;
}
return 0;
}输出结果为：
按照年龄升序排序：
Charlie 20 3000
Alice 25 4000
Bob 30 5000
David 35 6000
按照工资降序排序：
David 35 6000
Bob 30 5000
Alice 25 4000
Charlie 20 3000在上面的代码中，我们定义了一个名为Person的结构体，其中包含了姓名、年龄和工资三个字段。然后，我们又定义了两个比较函数cmpAge()和cmpSalary()，分别用于按照年龄升序和按照工资降序排序。 在main()函数中，我们创建了一个包含四个Person对象的vector，并初始化了一些值。然后，我们分别调用了两次sort()函数，分别按照年龄升序和按照工资降序排序。最后，我们使用两个循环分别打印出排序后的结果。
结构体内部运算符重载
在结构体内重载运算符，可以使我们更方便地对结构体进行排序。在C++中，可以通过重载小于号运算符<来实现结构体的排序。具体来说，如果我们想要按照某个字段升序排序，只需要在结构体中定义一个小于号运算符的重载函数，然后在排序时传入该函数即可。 下面是一个示例代码，演示如何在结构体内重载小于号运算符，并用sort()函数对该结构体进行排序：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct Person {
string name;
int age;
double salary;
bool operator < (const Person& other) const {
return age < other.age; // 按照年龄升序排序
}
};
int main() {
vector<Person> people = {
{"Alice", 25, 4000.0},
{"Bob", 30, 5000.0},
{"Charlie", 20, 3000.0},
{"David", 35, 6000.0},
};
sort(people.begin(), people.end());
for(auto p : people) {
cout << p.name << " " << p.age << " " << p.salary << endl;
}
return 0;
}输出结果为：
Charlie 20 3000
Alice 25 4000
Bob 30 5000
David 35 6000在上面的代码中，我们在Person结构体中重载了小于号运算符<，使其按照年龄升序排序。在main()函数中，我们创建了一个包含四个Person对象的vector，并初始化了一些值。然后，我们调用了一次sort()函数，传入了一个空的比较函数，因为我们已经在Person结构体内重载了小于号运算符。最后，我们使用一个循环打印出排序后的结果。 需要注意的是，重载小于号运算符时，需要将运算符重载函数声明为const成员函数，这是因为排序函数需要保证比较操作不会修改结构体的内容。
map容器的排序
map的键排序
map容器本身是有序的，因此不需要使用sort()函数对其进行排序。map容器是一种关联容器，其中的元素是按照键值有序排列的，因此我们可以说map容器本身就已经是排序好的了。 如果我们需要对map容器进行遍历，可以使用迭代器来访问其中的元素。map容器的迭代器按照键值升序排列，因此我们可以直接使用一个循环来遍历map容器中的所有元素。 下面是一个示例代码，演示如何使用迭代器遍历map容器：
#include <iostream>
#include <map>
using namespace std;
int main() {
map<string, int> scores = {
{"Alice", 80},
{"Bob", 70},
{"Charlie", 90},
{"David", 85},
};
for(auto it = scores.begin(); it != scores.end(); ++it) {
cout << it->first << ": " << it->second << endl;
}
return 0;
}输出结果为：
Alice: 80
Bob: 70
Charlie: 90
David: 85在上面的代码中，我们创建了一个名为scores的map容器，并初始化了一些键值对。然后，我们使用一个迭代器it遍历map容器中的所有元素，并打印出每个键值对的键和值。 需要注意的是，map容器的键和值是一一对应的，因此在遍历map容器时，需要使用迭代器的first和second成员来访问键和值。在上面的代码中，it->first代表当前迭代器指向的键，it->second代表当前迭代器指向的值。
map的值排序
map容器中的元素是按照键值有序排列的，因此无法直接使用sort()函数对其值进行排序。但是，我们可以将map容器中的键值对复制到一个vector容器中，然后对vector容器中的元素进行排序，最后再将排序后的结果更新到map容器中。 下面是一个示例代码，演示如何使用vector容器对map容器中的值进行排序：
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
map<string, int> scores = {
{"Alice", 80},
{"Bob", 70},
{"Charlie", 90},
{"David", 85},
};
vector<pair<string, int>> vec;
for(auto it = scores.begin(); it != scores.end(); ++it) {
vec.push_back(*it);
}
sort(vec.begin(), vec.end(), [](pair<string, int>& a, pair<string, int>& b){
return a.second > b.second; // 按值降序排列
});
scores.clear();
for(auto& p : vec) {
scores.insert(p);
}
for(auto it = scores.begin(); it != scores.end(); ++it) {
cout << it->first << ": " << it->second << endl;
}
return 0;
}输出结果为：
Charlie: 90
David: 85
Alice: 80
Bob: 70在上面的代码中，我们首先创建了一个名为scores的map容器，并初始化了一些键值对。然后，我们创建了一个vector容器vec，并使用循环将scores中的键值对复制到vec中。接着，我们调用了sort()函数并传入一个比较函数，用于按照值降序排列vec中的元素。由于vec中的元素是键值对，因此我们需要在比较函数中指定按照second成员排序。最后，我们清空了scores容器，再使用循环将排序后的键值对插入到scores容器中，并使用迭代器遍历scores容器，打印出每个键值对的键和值。 需要注意的是，在将排序后的键值对插入到map容器中时，我们使用了insert()函数，而不是直接使用=赋值运算符。这是因为map容器中的元素是按照键值有序排列的，因此如果我们直接使用=赋值运算符，可能会破坏原有的顺序关系。而使用insert()函数可以保证插入的新元素仍然按照键值有序排列。
sort对二维数组的排序
二维数组可以看作是一个包含若干个一维数组的数组，因此可以使用sort()函数对其进行排序。但是，需要注意的是，在使用sort()函数对二维数组排序时，需要自定义比较函数，以指定按照哪个元素进行排序。 下面是一个示例代码，演示如何使用sort()函数对二维数组进行排序：
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int a[][3] = {
{3, 1, 4},
{2, 8, 5},
{9, 7, 6},
};
int n = sizeof(a) / sizeof(a[0]); // 行数
int m = sizeof(a[0]) / sizeof(int); // 列数
sort(a, a + n, [](int* x, int* y){
return x[1] < y[1]; // 按第二列升序排列
});
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
cout << a[i][j] << ' ';
}
cout << endl;
}
return 0;
}输出结果为：
3 1 4
9 7 6
2 8 5 在上面的代码中，我们定义了一个名为a的二维数组，其中包含了三个一维数组，每个一维数组有三个元素。然后，我们使用sizeof()运算符计算出了行数和列数，并调用了sort()函数，并传入一个比较函数，用于按照第二列升序排列二维数组中的元素。由于sort()函数对于二维数组的排序需要在比较函数中指定按照哪个元素排序，因此我们在比较函数中指定了按照第二列排序。最后，我们使用两个嵌套循环遍历二维数组，并打印出每个元素的值。 需要注意的是，在比较函数中，我们使用了指针来表示二维数组中的一维数组。这是因为二维数组在传递给函数时，会自动转换为指向其第一行的指针，因此在比较函数中可以直接使用指针来表示一维数组。
