C++ 排序函数sort（）

一、sort () 函数是什么

在 C++ 的标准库中，sort()函数是一个强大且常用的工具，定义于<algorithm>头文件中 ，它就像是一个高效的 “排序大师”，专门负责对容器（如vector、array等）或普通数组中的元素进行排序。无论是处理简单的整数数组，还是复杂的自定义结构体，sort()函数都能轻松应对，将杂乱无章的数据按照我们期望的顺序排列得井然有序，为后续的数据处理和分析工作提供了极大的便利，接下来我们就深入了解一下它的具体使用方法。

二、sort () 函数基本语法

2.1 函数原型

sort()函数有两种常见的原型，能够适应不同的排序需求。第一种原型如下：

template<class RandomAccessIterator>

void sort (RandomAccessIterator first, RandomAccessIterator last);

在这个原型中，first和last都是随机访问迭代器，first指向要排序范围的起始位置，last指向要排序范围的结束位置的下一个位置 ，即排序范围是左闭右开区间[first, last)。举个例子，对于一个vector<int> vec，如果我们想对整个vector进行排序，可以这样调用：sort(vec.begin(), vec.end()); ，这里vec.begin()就是first，vec.end()就是last。

第二种原型增加了一个比较函数参数，用于自定义排序规则：

template<class RandomAccessIterator, class Compare>

void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

其中，comp是一个可调用对象（函数、函数指针或者函数对象），它定义了元素之间的比较方式。当comp(a, b)返回true时，表示a应该排在b前面。例如，我们想要对一个vector<int>进行降序排序，可以定义一个比较函数：

bool compare(int a, int b) {

return a > b;

}

然后这样调用sort()函数：sort(vec.begin(), vec.end(), compare); 。

2.2 头文件与命名空间

在使用sort()函数之前，我们需要包含<algorithm>头文件，它包含了各种常用的算法，sort()函数便是其中之一：

#include <algorithm>

同时，由于sort()函数位于std命名空间中，我们需要使用using namespace std;语句，或者在调用sort()函数时显式指定命名空间std::。例如：

using namespace std;

int main() {

int arr[5] = {3, 1, 4, 1, 5};

sort(arr, arr + 5);

return 0;

}

或者

int main() {

int arr[5] = {3, 1, 4, 1, 5};

std::sort(arr, arr + 5);

return 0;

}

这样，我们就完成了sort()函数使用前的准备工作，可以开始利用它对数据进行排序了。

三、sort () 函数的使用方法

3.1 默认排序（升序）

sort () 函数的默认行为是对元素进行升序排序，就像将杂乱的书籍按照书名的字母顺序排列一样，简单而直观，能满足许多常见的排序需求。下面分别展示对数组和vector进行默认排序的示例。

3.1.1 对数组进行默认排序

 #include <iostream> #include <algorithm> using namespace std; int main() { int arr[5] = { 3, 1, 4, 1, 5 }; sort(arr, arr + 5); cout << "排序后的数组: "; for (int i = 0; i < 5; ++i) { cout << arr[i] << " "; } cout << endl; return 0; }

在上述代码中，我们定义了一个包含 5 个元素的整型数组arr，然后调用sort(arr, arr + 5)对数组进行排序。arr指向数组的起始位置，arr + 5指向数组末尾的下一个位置，这样就指定了排序的范围。最后，通过循环打印出排序后的数组。运行这段代码，输出结果为：

排序后的数组: 1 1 3 4 5

可以看到，数组元素已经按照升序排列好了。

3.1.2 对 vector 进行默认排序

 #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> vec = { 3, 1, 4, 1, 5 }; sort(vec.begin(), vec.end()); cout << "排序后的vector: "; for (int num : vec) { cout << num << " "; } cout << endl; return 0; }

这里我们创建了一个vector<int>对象vec，并使用sort(vec.begin(), vec.end())对其进行排序。vec.begin()返回指向vector起始位置的迭代器，vec.end()返回指向vector末尾下一个位置的迭代器。同样，最后通过循环打印排序后的vector。运行结果如下：

排序后的vector: 1 1 3 4 5

由此可见，sort()函数对vector的默认排序效果与对数组的默认排序效果一致，都是将元素升序排列 。

3.2 自定义排序规则

在实际应用中，默认的升序排序可能无法满足所有需求，我们可能需要根据特定的条件对数据进行排序。这时候，sort()函数的自定义排序功能就派上用场了，通过提供自定义的比较函数，我们可以实现各种灵活的排序规则 。

3.2.1 使用比较函数实现降序排序

要实现降序排序，我们可以定义一个比较函数，在函数中改变比较的逻辑。以下是对数组和vector使用比较函数进行降序排序的示例：

 #include <iostream> #include <algorithm> using namespace std; // 比较函数，用于降序排序 bool compare(int a, int b) { return a > b; } int main() { // 对数组进行降序排序 int arr[5] = { 3, 1, 4, 1, 5 }; sort(arr, arr + 5, compare); cout << "降序排序后的数组: "; for (int i = 0; i < 5; ++i) { cout << arr[i] << " "; } cout << endl; // 对vector进行降序排序 vector<int> vec = { 3, 1, 4, 1, 5 }; sort(vec.begin(), vec.end(), compare); cout << "降序排序后的vector: "; for (int num : vec) { cout << num << " "; } cout << endl; return 0; }

在这个示例中，我们定义了compare函数，它接受两个整数参数a和b，并返回a > b，表示a应该排在b前面，从而实现了降序排序。然后，在main函数中，分别对数组和vector使用sort函数，并传入compare函数作为自定义的比较规则。运行代码，输出结果如下：

降序排序后的数组: 5 4 3 1 1

降序排序后的vector: 5 4 3 1 1

可以看到，数组和vector都成功地按照降序排列了。

3.2.2 使用标准库函数对象实现排序

除了自定义比较函数，C++ 标准库还提供了一些预定义的函数对象，如greater和less，可以更方便地实现升序和降序排序。其中greater用于降序排序，less用于升序排序（less是默认的比较方式，所以在默认排序时无需显式指定） 。示例代码如下：

 #include <iostream> #include <algorithm> #include <functional> #include <vector> using namespace std; int main() { vector<int> vec = { 3, 1, 4, 1, 5 }; // 使用greater实现降序排序 sort(vec.begin(), vec.end(), greater<int>()); cout << "使用greater降序排序后的vector: "; for (int num : vec) { cout << num << " "; } cout << endl; // 使用less实现升序排序（与默认排序效果相同） sort(vec.begin(), vec.end(), less<int>()); cout << "使用less升序排序后的vector: "; for (int num : vec) { cout << num << " "; } cout << endl; return 0; }

在这段代码中，我们首先包含了<functional>头文件，它提供了各种函数对象。然后，在sort函数中分别使用greater<int>()和less<int>()来指定排序顺序。运行结果如下：

使用greater降序排序后的vector: 5 4 3 1 1

使用less升序排序后的vector: 1 1 3 4 5

通过使用这些标准库函数对象，我们可以更简洁地实现常见的排序需求。

3.2.3 自定义复杂排序规则

有时候，我们需要根据更复杂的规则对数据进行排序，比如按数字的个位数大小排序，或者对结构体按照某个成员变量排序。下面是两个示例，展示如何实现这些复杂的排序规则 。

按个位数大小排序：

 #include <iostream> #include <algorithm> #include <vector> using namespace std; // 按个位数大小排序的比较函数 bool compareByUnit(int a, int b) { int unitA = a % 10; int unitB = b % 10; if (unitA != unitB) { return unitA < unitB; } else { return a < b; } } int main() { vector<int> vec = { 31, 12, 43, 14, 55 }; sort(vec.begin(), vec.end(), compareByUnit); cout << "按个位数大小排序后的vector: "; for (int num : vec) { cout << num << " "; } cout << endl; return 0; }

在这个示例中，compareByUnit函数首先获取两个数的个位数unitA和unitB，如果个位数不同，就按照个位数从小到大排序；如果个位数相同，则按照原数从小到大排序。运行代码，输出结果为：

按个位数大小排序后的vector: 12 14 31 43 55

对结构体按某个成员变量排序：

 #include <iostream> #include <algorithm> #include <vector> #include <string> using namespace std; // 定义学生结构体 struct Student { string name; int score; }; // 按成绩降序排序的比较函数 bool compareByScore(const Student& a, const Student& b) { return a.score > b.score; } int main() { vector<Student> students = { {"Alice", 85}, {"Bob", 90}, {"Charlie", 80} }; sort(students.begin(), students.end(), compareByScore); cout << "按成绩降序排序后的学生列表:" << endl; for (const Student& student : students) { cout << "姓名: " << student.name << ", 成绩: " << student.score << endl; } return 0; }

这里我们定义了一个Student结构体，包含姓名和成绩两个成员变量。compareByScore函数用于按成绩降序排序，在sort函数中传入这个比较函数，对students向量进行排序。运行结果如下：

按成绩降序排序后的学生列表:

姓名: Bob, 成绩: 90

姓名: Alice, 成绩: 85

姓名: Charlie, 成绩: 80

通过以上示例，我们可以看到sort()函数在自定义复杂排序规则方面的强大功能，能够满足各种不同的排序需求。无论是简单的数值排序，还是复杂的结构体排序，都能通过合适的比较函数轻松实现 。

四、sort () 函数的实现原理

4.1 结合多种排序算法

sort()函数之所以高效，是因为它并非依赖单一的排序算法，而是巧妙地结合了快速排序、插入排序和堆排序这三种经典算法 。快速排序以其平均时间复杂度为\(O(nlogn)\)的高效性，成为处理大数据集的首选。它通过选择一个基准元素，将数组分为两部分，使得左边部分的元素都小于基准，右边部分的元素都大于基准，然后递归地对左右两部分进行排序 。但在最坏情况下，快速排序的时间复杂度会退化到\(O(n^2)\)，比如当数据已经有序时，每次选择的基准都是最大或最小元素，导致划分极度不均匀 。

为了避免这种情况，sort()函数在递归深度超过一定阈值（通常是\(logn\)）时，会切换到堆排序。堆排序是一种基于二叉堆数据结构的排序算法，它的时间复杂度始终稳定在\(O(nlogn)\)，而且空间复杂度为\(O(1)\)，不会受到数据初始状态的影响 。堆排序通过构建最大堆或最小堆，不断将堆顶元素与堆尾元素交换，并调整堆结构，从而实现排序。

而当数据量较小时，插入排序的常数时间优势就凸显出来了 。插入排序就像是整理扑克牌，将一个数据插入到已经排好序的数组中的合适位置，时间复杂度在最好情况下为\(O(n)\)，平均和最坏情况下为\(O(n^2)\) 。sort()函数在分段递归后，当每一段的数据量小于某个阈值（通常是 16）时，会采用插入排序，因为此时插入排序的低常数时间开销比递归调用带来的额外开销更划算，能进一步提高排序效率 。通过这样的组合策略，sort()函数在各种数据规模和初始状态下都能表现出良好的性能。

4.2 不同数据规模下的策略

在面对不同规模的数据时，sort()函数会采取不同的排序策略 。当数据量较大时，优先使用快速排序进行分段递归，利用其平均性能优势快速将数据大致排序 。例如，对一个包含 10000 个元素的数组排序，快速排序可以迅速将数组分成多个较小的子数组，每个子数组的元素相对有序 。随着递归的进行，当子数组的大小逐渐减小到一定程度时，sort()函数会根据递归深度来判断是否切换到堆排序 。如果递归深度过深，继续使用快速排序可能会导致栈溢出或性能下降，此时堆排序就成为了更可靠的选择，确保在任何情况下都能以\(O(nlogn)\)的时间复杂度完成排序 。

当数据量较小时，比如数组元素个数小于 16，插入排序就派上用场了 。插入排序的操作简单直接，不需要额外的空间，对于小规模数据的排序效率较高 。它通过将每个元素插入到已排序部分的合适位置，逐步构建有序数组 。在这种情况下，插入排序的低常数时间开销使得它比其他复杂算法更具优势，能够快速完成排序任务 。通过这种动态调整排序算法的方式，sort()函数能够在不同数据规模下都实现高效排序，为用户提供了强大而可靠的排序工具 。

五、sort () 函数的应用场景

5.1 数据处理与分析

在数据处理与分析领域，sort()函数是一个极为重要的工具 。假设我们有一组销售数据，每个数据包含产品名称、销售数量和销售额 。为了分析哪种产品最畅销，我们可以使用sort()函数对销售数据按销售数量进行降序排序 。通过排序，我们能迅速找出销售数量最多的产品，进而深入分析其受欢迎的原因，为企业的生产和营销策略提供有力依据 。例如：

 #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; // 定义销售数据结构体 struct SaleData { string productName; int quantity; double revenue; }; // 按销售数量降序排序的比较函数 bool compareByQuantity(const SaleData& a, const SaleData& b) { return a.quantity > b.quantity; } int main() { vector<SaleData> sales = { {"ProductA", 100, 5000.0}, {"ProductB", 150, 7500.0}, {"ProductC", 80, 4000.0} }; sort(sales.begin(), sales.end(), compareByQuantity); cout << "按销售数量降序排序后的销售数据:" << endl; for (const SaleData& data : sales) { cout << "产品名称: " << data.productName << ", 销售数量: " << data.quantity << ", 销售额: " << data.revenue << endl; } return 0; }

运行上述代码，我们可以清晰地看到销售数量最多的产品排在首位，方便我们进行后续的分析。

5.2 算法竞赛与刷题

在算法竞赛和刷题中，sort()函数能极大地简化排序操作，提高解题效率 。许多算法问题都涉及到对数据的排序，比如寻找数组中的第 K 大元素 。我们可以使用sort()函数先对数组进行排序，然后直接获取第 K 大的元素 。在时间和空间复杂度要求严格的竞赛环境中，sort()函数的高效性尤为重要 。例如，在力扣（LeetCode）的第 215 题 “数组中的第 K 个最大元素” 中，我们可以这样解题：

 #include <iostream> #include <vector> #include <algorithm> using namespace std; int findKthLargest(vector<int>& nums, int k) { sort(nums.begin(), nums.end(), greater<int>()); return nums[k - 1]; } int main() { vector<int> nums = { 3, 2, 1, 5, 6, 4 }; int k = 2; int result = findKthLargest(nums, k); cout << "第" << k << "大的元素是: " << result << endl; return 0; }

通过sort()函数将数组降序排序，然后直接返回第 k 个元素，简洁高效地解决了问题。

5.3 实际项目开发

在实际项目开发中，sort()函数也有广泛的应用 。以学生成绩管理系统为例，假设我们有一个存储学生成绩的结构体数组，每个结构体包含学生的姓名、学号和成绩 。为了生成成绩报表，我们需要按成绩对学生进行排序 。使用sort()函数，我们可以轻松实现这一功能 。代码示例如下：

 #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; // 定义学生结构体 struct Student { string name; int id; double score; }; // 按成绩降序排序的比较函数 bool compareByScore(const Student& a, const Student& b) { return a.score > b.score; } int main() { vector<Student> students = { {"Alice", 1001, 85.5}, {"Bob", 1002, 90.0}, {"Charlie", 1003, 80.0} }; sort(students.begin(), students.end(), compareByScore); cout << "按成绩降序排序后的学生列表:" << endl; for (const Student& student : students) { cout << "姓名: " << student.name << ", 学号: " << student.id << ", 成绩: " << student.score << endl; } return 0; }

通过这个简单的示例，我们可以看到sort()函数在实际项目中对数据排序的重要作用，它使得数据的处理和展示更加有序和直观 。无论是小型项目还是大型企业级应用，sort()函数都能帮助开发者高效地管理和处理数据 。

六、使用 sort () 函数的常见错误及解决方法

在使用sort()函数时，可能会遇到一些常见的错误，了解这些错误并掌握相应的解决方法，能够帮助我们更高效地使用sort()函数 。

6.1 比较函数错误

比较函数的编写不规范是使用sort()函数时常见的错误之一。比较函数必须遵循严格弱序关系，即对于所有的a，comp(a, a)应返回false；如果comp(a, b)返回true，那么comp(b, a)应返回false；如果comp(a, b)返回true且comp(b, c)返回true，那么comp(a, c)应返回true 。如果比较函数违反了这些规则，可能会导致未定义行为，甚至程序崩溃 。

错误示例：

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

// 错误的比较函数，不满足严格弱序关系

bool wrongCompare(int a, int b) {

return a <= b;

}

int main() {

vector<int> vec = { 3, 1, 4, 1, 5 };

sort(vec.begin(), vec.end(), wrongCompare);

for (int num : vec) {

cout << num << " ";

}

cout << endl;

return 0;

}

在这个示例中，wrongCompare函数使用了<=进行比较，当a和b相等时，comp(a, b)和comp(b, a)都会返回true，这违反了严格弱序关系 。在某些情况下，这样的比较函数可能会导致程序出现段错误或其他未定义行为 。

正确示例：

 #include <iostream> #include <algorithm> #include <vector> using namespace std; // 正确的比较函数，满足严格弱序关系 bool correctCompare(int a, int b) { return a < b; } int main() { vector<int> vec = { 3, 1, 4, 1, 5 }; sort(vec.begin(), vec.end(), correctCompare); for (int num : vec) { cout << num << " "; } cout << endl; return 0; }

在这个示例中，correctCompare函数使用<进行比较，满足严格弱序关系，能够正确地对vector进行排序 。当遇到比较函数错误时，我们需要仔细检查比较函数的逻辑，确保它满足严格弱序关系 。

6.2 数据类型不支持

当数据类型不支持比较运算符时，使用sort()函数会出错 。例如，对于自定义类，如果没有重载比较运算符，直接使用sort()函数会导致编译错误 。

错误示例：

#include <iostream>

#include <algorithm>

#include <vector>

#include <string>

using namespace std;

// 定义自定义类

class MyClass {

public:

string name;

int value;

MyClass(const string& n, int v) : name(n), value(v) {}

};

int main() {

vector<MyClass> vec = { MyClass("Alice", 10), MyClass("Bob", 20) };

// 错误：MyClass没有重载比较运算符

sort(vec.begin(), vec.end());

return 0;

}

在这个示例中，MyClass类没有重载比较运算符，所以在调用sort(vec.begin(), vec.end());时会出现编译错误 。为了解决这个问题，我们需要重载比较运算符，或者提供一个自定义的比较函数 。

解决方法：

 #include <iostream> #include <algorithm> #include <vector> #include <string> using namespace std; // 定义自定义类 class MyClass { public: string name; int value; MyClass(const string& n, int v) : name(n), value(v) {} // 重载小于运算符 bool operator<(const MyClass& other) const { if (value != other.value) { return value < other.value; } return name < other.name; } }; int main() { vector<MyClass> vec = { MyClass("Alice", 10), MyClass("Bob", 20) }; sort(vec.begin(), vec.end()); for (const MyClass& obj : vec) { cout << "Name: " << obj.name << ", Value: " << obj.value << endl; } return 0; }

在这个修正后的示例中，我们在MyClass类中重载了<运算符，定义了MyClass对象之间的比较规则 。这样，sort()函数就可以正确地对vector<MyClass>进行排序了 。如果不想重载<运算符，也可以提供一个自定义的比较函数，在sort()函数中作为第三个参数传入，同样能实现对自定义类的排序 。

七、总结

在 C++ 编程的广阔领域中，sort()函数犹如一把万能钥匙，在数据处理和算法实现中发挥着不可或缺的作用 。它的出现，极大地简化了排序操作，无论是对简单的数值数组，还是复杂的自定义结构体，都能轻松应对 。通过本文的介绍，我们深入了解了sort()函数的基本语法、使用方法、实现原理、应用场景以及常见错误与解决方法 。希望读者能够熟练掌握sort()函数的使用技巧，在实际编程中灵活运用，提升代码的效率和质量 。