C++ sort函数完全指南：从基础排序到结构体多级排序实战-尧图网络科技

1. 从“排序”这个基础操作说起

在C++的世界里，无论你是刚入门的新手，还是已经写了几年业务逻辑的开发者，sort函数都是一个绕不开的话题。它太基础了，基础到很多教程可能一笔带过；但它又太重要了，重要到几乎每个涉及数据处理的C++项目都会用到它。我见过不少开发者，对sort的使用还停留在“默认升序”的阶段，一旦遇到降序或者稍微复杂一点的结构体排序，就开始手忙脚乱，要么去网上复制一段看不懂的代码，要么干脆自己写个冒泡排序。这其实挺可惜的，因为C++标准库里的sort是一个设计得非常精良的工具，用好了能极大提升代码效率和可读性。

今天，我们就来彻底拆解一下C++中sort的使用，不光是升序降序，更要深入到结构体排序、自定义比较逻辑这些实战中必然会遇到的场景。我会结合我这些年踩过的坑和总结的经验，让你不仅能“会用”，更能“懂为什么这么用”，甚至能写出更优雅、更高效的排序代码。无论你是正在准备面试，被“C++八股文”里的排序问题困扰，还是在实际开发中（比如用OpenCV处理数据、或者写个小游戏需要排行榜功能）遇到了排序需求，这篇文章都能给你提供直接的、可复现的解决方案。

2.`std::sort`的基石：理解它的工作方式与默认行为

在深入各种排序技巧之前，我们必须先夯实基础，理解std::sort到底是个什么东西，以及它默认是怎么工作的。很多模糊和错误的使用，根源都在于对基础概念的不清晰。

2.1`std::sort`是什么？不是`qsort`

首先，std::sort是C++标准模板库（STL）<algorithm>头文件提供的一个函数模板。它是一个泛型算法，这意味着它可以用于任何提供了随机访问迭代器的容器（比如std::vector,std::deque, 原生数组等），并且对元素类型没有特定要求，只要元素之间可以进行比较。

这里要特别提一下C语言的qsort。很多从C转过来的朋友会习惯性搜索qsort，但在C++中，std::sort是绝对的首选。原因很简单：性能和安全。

qsort通过函数指针接收一个比较函数，这个函数指针调用是无法内联的，并且每次比较都需要进行函数调用，开销较大。更重要的是，qsort使用void*指针来操作数据，这完全绕过了C++的类型系统，既不安全也不方便。

而std::sort是一个模板函数，它的比较器（无论是函数指针、函数对象还是lambda表达式）在编译期就确定了。编译器可以对其进行深度优化，包括内联比较操作，这使得std::sort的性能通常远高于qsort。此外，它使用迭代器，类型安全，与STL容器无缝集成。

所以，记住第一条经验法则：在C++中，忘记qsort，只用std::sort。

2.2 默认的升序排序：`operator<`是关键

std::sort函数最常见的形式是接受两个迭代器，表示要排序的范围[first, last)：

#include <algorithm> #include <vector> std::vector<int> vec = {5, 2, 8, 1, 9}; std::sort(vec.begin(), vec.end());

执行完这行代码后，vec中的元素会变成{1, 2, 5, 8, 9}。这是升序排序。

它为什么默认是升序？奥秘在于std::sort的默认行为。当你只提供范围迭代器而不提供自定义比较器时，sort会使用默认的std::less<>函数对象来进行元素间的比较。std::less<>对于大多数内置类型和标准库类型，其行为就是调用元素的operator<（小于运算符）。

也就是说，std::sort(vec.begin(), vec.end())等价于：

std::sort(vec.begin(), vec.end(), std::less<int>());

而std::less<int>()(a, b)本质上就是在判断a < b是否为真。排序算法根据这个“小于”关系，来重新排列元素，最终得到一个“升序”序列（即对于任意相邻元素，都有前一个 < 后一个）。

这里有一个非常重要的实操细节：如果你想让自己定义的结构体或类也能用默认的std::sort进行排序，你必须为该类型重载operator<。这是让自定义类型融入STL算法生态的关键一步。

struct Person { std::string name; int age; // 重载小于运算符，定义“Person对象之间的小于关系” // 这里我们按年龄升序定义 bool operator<(const Person& other) const { return age < other.age; } }; std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}}; std::sort(people.begin(), people.end()); // 正确！会使用我们重载的 operator<

排序后，people的顺序将是 Bob(25), Alice(30), Charlie(35)。

注意：重载operator<时，务必使其满足严格弱序要求。简单来说，它需要满足：
非自反性：comp(a, a)必须为false。
非对称性：若comp(a, b)为true，则comp(b, a)必须为false。
可传递性：若comp(a, b)为true且comp(b, c)为true，则comp(a, c)必须为true。大多数合理的比较逻辑（如数值比较、字符串字典序）天然满足这些条件，但如果你写的比较逻辑很复杂（比如涉及浮点数的精确相等判断），就需要小心。

2.3 排序的稳定性：什么时候需要关心？

std::sort默认提供的是不保证稳定的排序。所谓“不稳定排序”，意思是如果两个元素根据比较器被认为是“相等”的，那么它们在排序后的相对位置可能会改变。

C++提供了另一个算法std::stable_sort，它保证相等元素的相对顺序不变。但这是有代价的——std::stable_sort的平均时间复杂度通常比std::sort稍高，或者需要额外的内存空间。

那么，什么时候该用std::stable_sort呢？

一个经典的场景是“多级排序”。比如你先按分数降序排，再按姓名升序排。一种做法是先按姓名排（稳定排序），再按分数排（稳定排序），这样就能保证分数相同时，姓名保持有序。但更常见的做法是直接写一个复杂的比较器，一次比较两个字段。只有在比较器无法一次性表达所有排序规则，或者你需要进行多次、不同优先级的排序时，才需要考虑稳定性。

对于绝大多数单字段排序或者比较器能完整定义顺序的场景，直接用std::sort就足够了，它的性能通常是最好的。

3. 实现降序排序的三种主流方式

掌握了默认的升序，降序就是我们必须攻克的第一个关卡。在实际项目中，降序的需求极其普遍，比如显示排行榜、找最大值、按时间倒序排列新闻等。C++提供了至少三种清晰的方式来实现降序，各有其适用的场景。

3.1 使用标准库函数对象`std::greater<>`

这是最简洁、最推荐在简单场景下使用的方法。正如std::less<>对应升序，std::greater<>对应降序。

#include <algorithm> #include <functional> // 需要包含此头文件以使用 std::greater std::vector<int> vec = {5, 2, 8, 1, 9}; std::sort(vec.begin(), vec.end(), std::greater<int>());

排序后，vec变为{9, 8, 5, 2, 1}。

它的工作原理是：std::greater<int>()(a, b)返回a > b的结果。排序算法会根据这个“大于”关系来排列元素，最终得到降序序列。

优点：

意图清晰：一看就知道是降序。
零开销：和std::less一样，是编译期确定的函数对象，性能最优。
适用于内置类型和已定义operator>的类型。

缺点：

对于自定义类型，如果你的类没有重载operator>，那么std::greater<YourType>将无法编译。此时你需要为类重载operator>，或者使用下面两种方法。

3.2 使用Lambda表达式：灵活与直观的平衡

Lambda表达式是C++11以来最伟大的特性之一，用于定义临时的、匿名的函数对象。在排序中，它让你可以原地编写比较逻辑，代码非常紧凑和直观。

std::vector<int> vec = {5, 2, 8, 1, 9}; // 使用Lambda实现降序 std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; // 注意这里是 >， 表示当a大于b时，a应该排在b前面 });

Lambda表达式[](int a, int b) { return a > b; }解读：

[]：捕获列表，这里为空，表示不捕获任何外部变量。
(int a, int b)：参数列表，即被比较的两个元素。
{ return a > b; }：函数体，返回一个布尔值。这个返回值的含义至关重要：如果希望 a 排在 b 的前面，就返回true。

所以，对于降序，我们希望大的数排在前面，因此当a > b为真时，a应该排在b前面，所以返回true。

Lambda方式的优点：

极度灵活：不仅可以实现简单的>或<，可以写任何复杂的比较逻辑。
无需修改类定义：不需要为自定义类型重载operator<或operator>，比较逻辑完全在调用sort的地方定义。
代码位置集中：比较逻辑紧挨着排序调用，便于阅读。

这是我最常用、也最推荐的方法，尤其是在项目代码中。它平衡了简洁性、灵活性和可读性。

3.3 定义自定义比较函数或函数对象

这是比较传统的方式，在Lambda表达式出现之前是主流。它适用于比较逻辑非常复杂，或者需要在多个地方复用的情况。

方式一：普通函数（或静态函数）

bool compareDesc(int a, int b) { return a > b; } std::vector<int> vec = {5, 2, 8, 1, 9}; std::sort(vec.begin(), vec.end(), compareDesc); // 传入函数指针

方式二：函数对象（仿函数）

struct CompareDesc { bool operator()(int a, int b) const { return a > b; } }; std::vector<int> vec = {5, 2, 8, 1, 9}; std::sort(vec.begin(), vec.end(), CompareDesc()); // 传入函数对象实例

函数对象相比普通函数的优势：

可以携带状态：函数对象的类可以有成员变量，从而让比较逻辑依赖外部状态。

struct CompareByThreshold { int threshold; CompareByThreshold(int t) : threshold(t) {} bool operator()(int a, int b) const { // 复杂的、依赖于threshold的比较逻辑 if (a > threshold && b <= threshold) return true; // ... 其他规则 return a > b; } }; std::sort(vec.begin(), vec.end(), CompareByThreshold(5));

更容易被编译器优化：和std::less一样，函数对象的operator()调用通常可以被内联。

三种方式如何选择？

简单内置类型降序：用std::greater<>()，最简洁。
绝大多数情况，尤其是自定义类型或逻辑稍复杂：用Lambda表达式，它是现代C++的惯用法。
比较逻辑极其复杂、需要复用、或需要携带状态：考虑使用函数对象。
普通函数的方式现在已较少使用，除非是为了兼容旧的C风格接口。

4. 结构体/类排序：从单字段到多级排序实战

对基本数据类型的排序只是开胃菜，真正的挑战来自于对自定义结构体或对象的排序。这在业务代码中无处不在，比如对学生按成绩排序、对商品按价格和销量排序、对日志按时间和级别排序等等。

4.1 基础：重载`operator<`实现默认排序

正如第2.2节提到的，让自定义类型支持std::sort(vec.begin(), vec.end())这种默认调用的方式，就是重载operator<。

struct Student { int id; std::string name; double score; // 按分数升序排序 bool operator<(const Student& other) const { return score < other.score; } }; std::vector<Student> students = {{1, "Alice", 85.5}, {2, "Bob", 92.0}, {3, "Charlie", 78.5}}; std::sort(students.begin(), students.end()); // 排序后：Charlie(78.5), Alice(85.5), Bob(92.0)

但这里有一个重要的“坑”需要避免：如果你在同一个程序中，有时需要按分数排，有时需要按姓名排，怎么办？重载operator<只能定义一种默认顺序。频繁修改operator<的定义是糟糕的设计，它会使得代码的意图模糊，且容易引发错误。

正确的做法是：不要滥用operator<。仅当你这个类型在绝大多数上下文中有一种公认的、自然的“小于”语义时（比如Point按坐标字典序，Date按时间先后），才重载它。对于业务实体（如Student,Order），其排序规则通常是场景相关的，更适合用Lambda或自定义比较器。

4.2 使用Lambda表达式：按需定义排序规则

Lambda表达式是处理结构体排序的利器。它允许你在调用排序的地方，即时指定按哪个字段、以何种方式排序。

std::vector<Student> students = {...}; // 场景1：按分数降序排列（排行榜） std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { return a.score > b.score; // 分数高的在前 }); // 场景2：按姓名升序排列（字典序） std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { return a.name < b.name; }); // 场景3：按id升序排列 std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { return a.id < b.id; });

你看，我们不需要修改Student结构体，就可以轻松实现三种不同的排序规则，代码意图非常清晰。

4.3 多级排序（多关键字排序）

这是面试和实战中的高频考点。所谓多级排序，就是先按第一个字段排，如果第一个字段相等，再按第二个字段排，以此类推。例如，先按分数降序，分数相同的再按姓名升序。

用Lambda表达式可以非常优雅地实现：

std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { // 第一优先级：分数降序 if (std::abs(a.score - b.score) > 1e-9) { // 处理浮点数比较 return a.score > b.score; // 分数高的在前 } // 第二优先级：分数相同时，姓名升序 return a.name < b.name; });

这里有一个关键技巧：对于浮点数（如double score）的直接相等==比较是危险的，因为浮点数有精度误差。通常我们判断两个浮点数是否“相等”，是判断它们的差值是否在一个极小的范围内（如1e-9）。在排序比较时，如果差值在这个范围内，我们就认为它们“相等”，进而去比较下一个字段。

另一种更通用、可读性可能更好的写法是，利用逻辑或运算符的短路特性：

std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { // 先比较分数（降序） if (a.score != b.score) { return a.score > b.score; } // 分数相等时，再比较姓名（升序） return a.name < b.name; });

对于整数和字符串，可以直接用!=和==。对于浮点数，如果需要精确判断，还是需要用差值法。

更复杂的三级排序（例如：分数降序 -> 姓名升序 -> ID升序）也是类似的模式：

std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) { if (a.score != b.score) return a.score > b.score; if (a.name != b.name) return a.name < b.name; return a.id < b.id; // 所有前序字段都相等时，按id排 });

这种链式比较的逻辑非常清晰，也易于扩展。

4.4 使用函数对象实现可复用的复杂比较器

当你的多级排序逻辑非常复杂，或者需要在程序的多个不同模块中使用相同的排序规则时，将其封装成一个函数对象是更好的选择。这提高了代码的复用性和可维护性。

class StudentScoreNameComparator { public: bool operator()(const Student& a, const Student& b) const { // 复杂的比较逻辑，可能还依赖于外部配置 if (a.score != b.score) return a.score > b.score; // 可能对姓名进行一些处理后再比较，比如不区分大小写 std::string nameA = a.name; std::string nameB = b.name; std::transform(nameA.begin(), nameA.end(), nameA.begin(), ::tolower); std::transform(nameB.begin(), nameB.end(), nameB.begin(), ::tolower); return nameA < nameB; } }; // 在代码中使用 std::sort(students.begin(), students.end(), StudentScoreNameComparator());

如果比较逻辑需要依赖运行时状态，函数对象的优势就更明显了：

class ComparatorByWeightedScore { double weight_midterm; double weight_final; public: ComparatorByWeightedScore(double w1, double w2) : weight_midterm(w1), weight_final(w2) {} bool operator()(const Student& a, const Student& b) const { double totalA = a.midterm * weight_midterm + a.final * weight_final; double totalB = b.midterm * weight_midterm + b.final * weight_final; return totalA > totalB; // 按加权总分降序 } }; // 根据不同的权重方案进行排序 std::sort(students.begin(), students.end(), ComparatorByWeightedScore(0.4, 0.6)); std::sort(students.begin(), students.end(), ComparatorByWeightedScore(0.3, 0.7));

5. 进阶技巧与性能优化实战

掌握了基本用法后，我们来看看一些能让你代码更高效、更安全的进阶技巧。这些技巧来自于实际项目中的经验总结，能帮你避开不少坑。

5.1 如何正确排序结构体指针的容器？

我们经常遇到容器里存放的不是对象本身，而是对象的指针（或智能指针），例如std::vector<Student*>。这时直接排序会出问题。

std::vector<Student*> studentPtrs = {&s1, &s2, &s3}; std::sort(studentPtrs.begin(), studentPtrs.end()); // 错误！

上面的代码会按照指针的地址值进行排序，这通常不是我们想要的。我们想按照指针所指向的对象的内容来排序。

解决方案：在比较器里解引用指针。

// 使用Lambda，按分数降序排列指针 std::sort(studentPtrs.begin(), studentPtrs.end(), [](const Student* a, const Student* b) { return a->score > b->score; // 注意：比较的是指向的对象 }); // 使用函数对象也可以 struct CompareStudentPtrByScore { bool operator()(const Student* a, const Student* b) const { return a->score > b->score; } }; std::sort(studentPtrs.begin(), studentPtrs.end(), CompareStudentPtrByScore());

重要提醒：确保指针容器中的指针都是有效的（非空且指向合法对象），并且在排序期间，这些对象不会被销毁或移动。使用智能指针（如std::vector<std::shared_ptr<Student>>）是更安全的选择，比较器的写法类似：[](const std::shared_ptr<Student>& a, const std::shared_ptr<Student>& b) { return a->score > b->score; }。

5.2 使用`std::begin`/`std::end`与成员函数`begin`/`end`

对于标准容器（如vector,deque,array），使用成员函数vec.begin()和vec.end()是标准的。对于原生数组，它们没有成员函数。为了写出通用的代码，可以使用非成员函数std::begin(arr)和std::end(arr)，它们对容器和原生数组都有效。

int c_array[] = {5, 3, 1, 4, 2}; std::sort(std::begin(c_array), std::end(c_array)); // 正确且通用 std::vector<int> vec = {5, 3, 1, 4, 2}; std::sort(std::begin(vec), std::end(vec)); // 同样正确，但通常直接用 vec.begin() 更常见

在泛型编程模板中，使用std::begin/std::end会让你的代码更通用。

5.3 排序部分范围与`std::nth_element`

std::sort排序整个范围。但有时我们只需要部分结果，比如找“前10名”或者“中位数”。全排序是O(N log N)，如果只需要部分有序，有更高效的算法。

排序部分范围：std::sort本身就可以只对一部分进行排序。

std::vector<int> vec = {9, 3, 6, 1, 7, 2, 8, 4, 5}; // 只对前5个元素排序 std::sort(vec.begin(), vec.begin() + 5); // 结果：{1, 3, 6, 7, 9, 2, 8, 4, 5}， 只有前5个是有序的

std::nth_element：部分排序的利器。这个算法能保证：

位于第 n 个位置（迭代器指向）的元素，就是如果整个数组全排序后应该出现在那个位置的元素。
在这个位置之前的元素都不大于它，之后的元素都不小于它。但它不保证前后两部分内部是有序的。它的平均时间复杂度是O(N)，比全排序快。

std::vector<int> vec = {9, 3, 6, 1, 7, 2, 8, 4, 5}; auto mid = vec.begin() + vec.size() / 2; // 指向中间位置的迭代器 std::nth_element(vec.begin(), mid, vec.end()); // 此时 *mid 就是中位数。mid之前的元素都 <= 中位数，之后的都 >= 中位数。 // 例如，可能的结果：{3, 1, 2, 4, 5, 9, 8, 7, 6}， 5在中间，前后无序但满足大小关系。 // 找前三名（最大的三个数） auto third = vec.begin() + 2; std::nth_element(vec.begin(), third, vec.end(), std::greater<int>()); // 现在 vec[0], vec[1], vec[2] 就是最大的三个数（但不一定按顺序） // 如果还需要这前三名内部有序，可以再对 [vec.begin(), third+1) 这个范围做一次 sort std::sort(vec.begin(), third + 1, std::greater<int>());

当你只需要找第K大/小的元素，或者找前K个元素（不要求内部顺序）时，std::nth_element是性能最优的选择。

5.4 性能考量：移动语义与`std::sort`的复杂度

std::sort的平均时间复杂度是O(N log N)，最坏情况下（理论上）也是O(N log N)，这是因为它通常使用内省排序（IntroSort），结合了快速排序、堆排序和插入排序的优点。

对于自定义类型，排序的性能不仅取决于比较操作的成本，还取决于交换（或移动）元素的成本。在C++11之后，如果你的类定义了移动构造函数和移动赋值运算符，并且它们比拷贝操作更高效（例如类内部有动态分配的内存），那么std::sort在重排元素时会使用移动语义，从而大幅提升性能。

struct BigData { std::vector<int> hugeVector; // ... 其他成员 // 定义移动构造函数和移动赋值运算符 BigData(BigData&& other) noexcept : hugeVector(std::move(other.hugeVector)) {} BigData& operator=(BigData&& other) noexcept { if (this != &other) { hugeVector = std::move(other.hugeVector); } return *this; } // 也需要定义比较运算符以便排序 bool operator<(const BigData& other) const { /* ... */ } }; std::vector<BigData> bigVec; std::sort(bigVec.begin(), bigVec.end()); // 这里会高效地使用移动操作

因此，对于管理资源的自定义类型，实现移动语义是优化其在容器中排序性能的关键。

6. 常见“坑”与调试技巧

即使理解了原理，在实际编码中还是会遇到一些意想不到的问题。这里分享几个我踩过的坑和对应的调试方法。

6.1 比较器不符合严格弱序导致的崩溃

这是最隐蔽也最危险的错误。如果你提供的比较函数（或Lambda）不满足“严格弱序”的要求（见2.2节），std::sort的行为是未定义的。在调试模式下，某些标准库实现可能会抛出异常或触发断言。在发布模式下，它可能导致程序崩溃、死循环或产生错误的排序结果。

典型错误示例1：浮点数的相等返回true

std::sort(vec.begin(), vec.end(), [](double a, double b) { return a <= b; // 错误！违反了非自反性（a <= a 为 true）和非对称性 });

修正：对于升序，应该用<；对于降序，用>。

典型错误示例2：复杂的、不可传递的比较逻辑

// 假设想按除以5的余数排序，但余数相等时想保持原顺序（这本身就不稳定） std::sort(vec.begin(), vec.end(), [](int a, int b) { return (a % 5) < (b % 5); }); // 这个比较器本身是满足严格弱序的（因为整数比较<是满足的）。 // 但如果你错误地认为它能“保持原顺序”，那就错了。std::sort是不稳定的。 // 如果需要稳定，应用 std::stable_sort。

调试方法：当你发现排序结果诡异或程序在sort处崩溃时，首先仔细检查你的比较器。确保它对于任何两个元素a和b：

comp(a, a)一定是false。
如果comp(a, b)为true，则comp(b, a)必须为false。
逻辑上不能出现comp(a, b)为真，comp(b, c)为真，但comp(a, c)为假的情况。

可以在比较器函数内部加入断言或打印语句来验证。

6.2 在比较器中修改被排序元素

绝对禁止在比较器函数中修改被比较的元素。这同样会导致未定义行为，因为排序算法依赖于比较结果的一致性，而修改元素会破坏这种一致性。

// 错误示例：非常危险的比较器 std::sort(vec.begin(), vec.end(), [](int& a, int& b) { // 错误地使用了非常量引用 a = a % 10; // 修改了元素！ b = b % 10; return a < b; });

比较器函数应该是一个“纯”的、无副作用的函数，只读取参数，返回比较结果。

6.3 处理浮点数排序的特殊性

浮点数（float,double）有精度限制，直接使用==或!=比较是否相等是不可靠的。这在多级排序中尤为重要。

struct Data { double value; int id; }; std::vector<Data> items = {{3.1415926535, 1}, {3.1415926536, 2}, {3.14, 3}}; // 意图：按value降序，value相同时按id升序 std::sort(items.begin(), items.end(), [](const Data& a, const Data& b) { // 错误写法：直接使用 a.value != b.value // if (a.value != b.value) return a.value > b.value; // return a.id < b.id; // 正确写法：使用一个很小的epsilon来判断“相等” const double epsilon = 1e-10; if (std::abs(a.value - b.value) > epsilon) { return a.value > b.value; } return a.id < b.id; });

对于大多数应用，定义一个全局的epsilon（如1e-9或1e-12）是可行的。对于科学计算等精度要求极高的场景，可能需要根据数值的量级来动态确定epsilon。

6.4 迭代器失效与排序

std::sort接受的是迭代器，它会在原地重新排列元素。这意味着排序操作不会导致容器本身的迭代器失效（对于vector,deque,array这类连续内存容器，所有迭代器在排序后都可能失效，但排序函数返回后，新的begin()和end()依然是有效的）。但是，如果你在容器中存储的是指针或引用，并且排序过程中这些指针/引用所指向的对象本身被移动或交换了，那么你需要理解这一点。

对于std::list，它有自己的成员函数sort()，因为std::sort要求随机访问迭代器，而list提供的是双向迭代器。所以对list排序应该用myList.sort()或myList.sort(comparator)。

7. 综合案例：一个简单的成绩排名系统

让我们用一个综合案例把上面的知识点串起来。假设我们要实现一个学生成绩排名系统，数据从文件或数据库读入，我们需要提供多种排序视图。

#include <iostream> #include <vector> #include <algorithm> #include <string> #include <fstream> #include <iomanip> struct StudentRecord { int studentId; std::string name; double chinese; double math; double english; double total() const { return chinese + math + english; } // 计算总分 }; class GradeRankingSystem { private: std::vector<StudentRecord> records; public: void loadFromFile(const std::string& filename) { std::ifstream file(filename); // 简单的读取逻辑，假设文件格式：ID Name Chinese Math English int id; std::string name; double c, m, e; while (file >> id >> name >> c >> m >> e) { records.push_back({id, name, c, m, e}); } } // 1. 按总分降序排名（经典排行榜） void rankByTotal() { std::sort(records.begin(), records.end(), [](const StudentRecord& a, const StudentRecord& b) { return a.total() > b.total(); }); printRanking("按总分排名"); } // 2. 按数学成绩降序，数学相同按语文降序 void rankByMathThenChinese() { std::sort(records.begin(), records.end(), [](const StudentRecord& a, const StudentRecord& b) { const double eps = 1e-9; if (std::abs(a.math - b.math) > eps) { return a.math > b.math; } // 数学成绩“相等”时，按语文成绩排 return a.chinese > b.chinese; }); printRanking("按数学->语文成绩排名"); } // 3. 按姓名升序（字典序） void rankByName() { std::sort(records.begin(), records.end(), [](const StudentRecord& a, const StudentRecord& b) { return a.name < b.name; }); printRanking("按姓名排序"); } // 4. 查找总分在前10%的学生（使用 std::nth_element） void findTop10Percent() { if (records.empty()) return; size_t topN = records.size() * 0.1; if (topN == 0) topN = 1; // 至少一个 // 使用 nth_element 找到第 topN 个位置的边界 auto nth = records.begin() + (topN - 1); std::nth_element(records.begin(), nth, records.end(), [](const StudentRecord& a, const StudentRecord& b) { return a.total() > b.total(); // 降序 }); // 此时，[begin, nth] 包含了前 topN 个最大的元素，但内部无序 std::vector<StudentRecord> topStudents(records.begin(), nth + 1); // 如果需要，可以对这前 topN 名再按总分精确排序 std::sort(topStudents.begin(), topStudents.end(), [](const StudentRecord& a, const StudentRecord& b) { return a.total() > b.total(); }); std::cout << "\n=== 总分前 " << topN << " 名学生 ===" << std::endl; for (const auto& s : topStudents) { std::cout << std::setw(10) << s.name << " 总分: " << s.total() << std::endl; } } private: void printRanking(const std::string& title) const { std::cout << "\n=== " << title << " ===" << std::endl; std::cout << std::left << std::setw(5) << "Rank" << std::setw(10) << "ID" << std::setw(15) << "Name" << std::setw(8) << "Chinese" << std::setw(8) << "Math" << std::setw(8) << "English" << std::setw(8) << "Total" << std::endl; int rank = 1; for (const auto& rec : records) { std::cout << std::left << std::setw(5) << rank++ << std::setw(10) << rec.studentId << std::setw(15) << rec.name << std::setw(8) << std::fixed << std::setprecision(1) << rec.chinese << std::setw(8) << rec.math << std::setw(8) << rec.english << std::setw(8) << rec.total() << std::endl; } } }; int main() { GradeRankingSystem sys; sys.loadFromFile("grades.txt"); // 假设有数据文件 sys.rankByTotal(); sys.rankByMathThenChinese(); sys.rankByName(); sys.findTop10Percent(); return 0; }

这个案例展示了：