目录

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 <vector>
#include <algorithm>

using namespace std;

int main() {
    //vector<vector<int> > arr(n, vector<int>(m));//arr[n][m];
    vector<vector<int>> arr = {{3, 2}, {1, 4}, {7, 6}};
    sort(arr.begin(), arr.end(), [](const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1];
    });
    for (const auto& v : arr) {
        cout << "[" << v[0] << ", " << v[1] << "]" << endl;
    }
    return 0;
}

输出结果为： 

[3, 2]
[1, 4]
[7, 6]