C++|sort函数

参考：C++中sort函数使用方法

头文件

#include <algorithm> // 包含sort函数

函数原型

sort 函数有两种形式的原型：

1. 对于数组或类似数组的对象：

void sort(ForwardIterator first,
          ForwardIterator last);

2. 对于数组或类似数组的对象，允许自定义比较函数：

void sort(ForwardIterator first,
          ForwardIterator last,
          StrictWeakOrdering comp);

参数说明

• first 和 last 是迭代器，分别指向要排序的序列的起始位置和结束位置（不包括结束位置）。
• comp 是一个可选的比较函数或函数对象，它接受两个参数并返回一个布尔值，指示第一个参数是否应该排在第二个参数之前。

示例

下面是一个使用 sort 函数对 vector 进行排序的示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {4, 1, 3, 5, 2};

    // 使用默认比较，即元素类型的<运算符
    std::sort(numbers.begin(), numbers.end());

    // 打印排序后的vector
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

多样化数据类型和自定义比较

如果容器中的元素是自定义的类或结构体，你需要重载 < 运算符来定义元素的比较逻辑。下面是一个示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 定义一个结构体
struct Person {
    std::string name;
    int age;

    // 重载<运算符，用于比较Person对象
    bool operator<(const Person& other) const {
        return age < other.age; // 按年龄排序
    }
};

int main() {
    std::vector<Person> people;
    people.push_back({"Alice", 30});
    people.push_back({"Bob", 25});
    people.push_back({"Charlie", 35});

    // 使用默认比较，因为Person结构体重载了<运算符
    std::sort(people.begin(), people.end());

    // 打印排序后的vector
    for (const auto& person : people) {
        std::cout << person.name << " (" << person.age << ") ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，Person 结构体重载了 < 运算符，以便 sort 函数可以根据 age 成员变量对 Person 对象进行排序。如果你需要不同的排序标准，你可以定义一个自定义比较函数或函数对象，并将其作为第三个参数传递给 sort 函数。

如何反向排序？

在C++中，如果你想要进行反向排序，你可以使用标准库中的 greater 函数，或者自定义一个比较函数或函数对象。以下是两种方法的示例：

使用 std::greater

你可以使用 std::greater 来创建一个比较函数，它将比较两个元素并返回它们是否应该反向排序。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {4, 1, 3, 5, 2};

    // 使用std::greater来实现反向排序
    std::sort(numbers.begin(), numbers.end(), std::greater<int>());

    // 打印排序后的vector
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，std::greater<int>() 创建了一个比较函数对象，它将比较两个 int 类型的元素，并返回它们是否应该反向排序。

自定义比较函数

你也可以定义一个自定义比较函数，该函数接受两个参数并返回 true 如果第一个参数应该排在第二个参数之后。

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数
bool reverseCompare(int a, int b) {
    return a > b; // 如果a大于b，返回true，实现反向排序
}

int main() {
    std::vector<int> numbers = {4, 1, 3, 5, 2};

    // 使用自定义比较函数进行反向排序
    std::sort(numbers.begin(), numbers.end(), reverseCompare);

    // 打印排序后的vector
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，reverseCompare 函数接受两个 int 类型的参数，并返回 true 如果第一个参数应该排在第二个参数之后，从而实现反向排序。

使用Lambda表达式

你还可以使用Lambda表达式来创建一个简洁的比较函数。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {4, 1, 3, 5, 2};

    // 使用Lambda表达式进行反向排序
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b;
    });

    // 打印排序后的vector
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，Lambda表达式 [](int a, int b) { return a > b; } 创建了一个匿名函数对象，它接受两个 int 类型的参数并返回 true 如果第一个参数应该排在第二个参数之后。这种方法在代码中非常简洁，特别是当比较逻辑简单时。