C++sort排序

sort使用方法

在 C++ 中，sort 函数是 <algorithm> 头文件中的一个功能强大的工具，用于对给定范围内的元素进行排序。以下是 sort 函数的基本用法：

#include <algorithm> // 包含 sort 函数的头文件
#include <vector>    // 如果使用 vector
// sort 函数原型：
// void sort(iterator first, iterator last, Compare comp);
// 对数组进行排序
void sortArrayExample() {
    int arr[] = {32, 71, 12, 45, 26, 80, 53, 33};
    int n = sizeof(arr) / sizeof(arr[0]);
    // 默认升序排序
    sort(arr, arr + n);
    // 打印排序后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
// 对 vector 进行排序
void sortVectorExample() {
    vector<int> vec = {32, 71, 12, 45, 26, 80, 53, 33};
    // 默认升序排序
    sort(vec.begin(), vec.end());
    // 打印排序后的 vector
    for (int num : vec) {
        cout << num << " ";
    }
    cout << endl;
}
// 使用自定义比较函数进行降序排序
void sortDescendingExample() {
    int arr[] = {32, 71, 12, 45, 26, 80, 53, 33};
    int n = sizeof(arr) / sizeof(arr[0]);
    // 使用 greater<int> 作为比较函数进行降序排序
    sort(arr, arr + n, greater<int>());
    // 打印排序后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
int main() {
    sortArrayExample();
    sortVectorExample();
    sortDescendingExample();
    return 0;
}

这里是如何使用 sort 函数的几个要点：

1. sort 函数的第一个参数是迭代器，指向要排序的序列的第一个元素。
2. 第二个参数是迭代器，指向要排序的序列的最后一个元素之后的元素（半开区间）。
3. 第三个参数是可选的，是一个比较函数，用于定义排序的顺序。如果没有提供，默认使用 < 运算符，即升序排序。
4. 如果要实现降序排序，可以使用 std::greater<T>() 或者自定义比较函数。
   在自定义比较函数时，它应该接受两个同类型的参数，并返回一个布尔值，指示第一个参数是否应该排在第二个参数之前。例如，为了实现降序排序，可以使用 std::greater<T>()，或者自定义一个比较函数如下：

// 自定义比较函数
bool customCompare(int a, int b) {
    return a > b; // 降序排序
}
// 使用自定义比较函数进行排序
sort(arr, arr + n, customCompare);

使用 sort 函数时，确保您已经包含了 <algorithm> 头文件。

内置比较函数

在 C++ 标准库中，除了 std::greater 之外，还有几个预定义的比较函数，它们都可以用作 sort 等算法的第三个参数。以下是一些常用的比较函数：

1. std::less - 默认的比较函数，用于升序排序。
2. std::greater - 用于降序排序。
3. std::less_equal - 用于非严格升序排序（允许相等元素）。
4. std::greater_equal - 用于非严格降序排序（允许相等元素）。
5. std::equal_to - 用于排序，但保持元素的原始顺序（不进行排序）。
6. std::not_equal_to - 用于排序，但保持元素的原始顺序（不进行排序）。
   以下是这些比较函数的示例用法：

#include <algorithm> // 包含 sort 函数和比较函数的头文件
#include <vector>
#include <iostream>
int main() {
    std::vector<int> vec = {32, 71, 12, 45, 26, 80, 53, 33};
    // 使用 std::less 升序排序
    std::sort(vec.begin(), vec.end(), std::less<int>());
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << "\n"; // 输出排序后的结果
    // 使用 std::greater 降序排序
    std::sort(vec.begin(), vec.end(), std::greater<int>());
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << "\n"; // 输出排序后的结果
    // 使用 std::less_equal 非严格升序排序
    std::sort(vec.begin(), vec.end(), std::less_equal<int>());
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << "\n"; // 输出排序后的结果
    // 使用 std::greater_equal 非严格降序排序
    std::sort(vec.begin(), vec.end(), std::greater_equal<int>());
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << "\n"; // 输出排序后的结果
    // 使用 std::equal_to 和 std::not_equal_to 通常不用于排序，
    // 因为它们不改变元素的相对顺序。
    return 0;
}

通常，std::equal_to 和 std::not_equal_to 并不用于排序，因为它们不会改变元素的相对顺序。这些函数更多用于搜索算法（如 std::binary_search）或用于需要比较两个元素是否相等或不相等的情况。
除了使用标准库中的比较函数，你还可以定义自己的比较函数，以满足特定的排序需求。自定义比较函数应该接受两个参数，并返回一个布尔值，表示第一个参数是否应该排在第二个参数之前。例如：

bool customCompare(int a, int b) {
    // 根据特定条件排序，例如按照绝对值大小升序排序
    return abs(a) < abs(b);
}
std::sort(vec.begin(), vec.end(), customCompare);

如何自定义比较函数

在 C++ 中，你可以通过传递一个自定义的比较函数（或 lambda 表达式）给 std::sort 函数来自定义排序规则。这个比较函数需要接受两个同类型的参数，并返回一个布尔值，表示第一个参数是否应该排在第二个参数之前。
以下是自定义排序规则的几种方法：

使用函数指针

你可以定义一个普通的函数，然后传递它的指针给 std::sort。

#include <algorithm> // 包含 std::sort
#include <vector>
#include <iostream>
// 自定义比较函数
bool customCompare(int a, int b) {
    return a > b; // 降序排序
}
int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};
    // 使用自定义比较函数进行排序
    std::sort(vec.begin(), vec.end(), customCompare);
    // 输出排序后的向量
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

使用 lambda 表达式

在 C++11 及更高版本中，你可以使用 lambda 表达式来定义一个内联的比较函数。

#include <algorithm> // 包含 std::sort
#include <vector>
#include <iostream>
int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};
    // 使用 lambda 表达式进行降序排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b;
    });
    // 输出排序后的向量
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

使用函数对象（Functor）

你可以定义一个实现了 operator() 的类，即函数对象，然后传递它的实例给 std::sort。

#include <algorithm> // 包含 std::sort
#include <vector>
#include <iostream>
// 自定义函数对象
struct CustomCompare {
    bool operator()(int a, int b) const {
        return a > b; // 降序排序
    }
};
int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};
    // 使用函数对象进行排序
    std::sort(vec.begin(), vec.end(), CustomCompare());
    // 输出排序后的向量
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

以上任何一种方法都可以让你自定义排序规则，使得 std::sort 能够按照你指定的顺序排列元素。