目录

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 

在上面的代码中,我们创建了一个名为numsvector容器,并初始化了一些整数值。然后,我们先调用了一次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

在上面的代码中,我们创建了一个名为scoresmap容器,并初始化了一些键值对。然后,我们使用一个迭代器it遍历map容器中的所有元素,并打印出每个键值对的键和值。 需要注意的是,map容器的键和值是一一对应的,因此在遍历map容器时,需要使用迭代器的firstsecond成员来访问键和值。在上面的代码中,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

在上面的代码中,我们首先创建了一个名为scoresmap容器,并初始化了一些键值对。然后,我们创建了一个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]

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐