C++中的sort与自定义排序详解

基本使用与原理

std::sort 是一个模板函数，常见签名如下：

template<class RandomIt>
void sort(RandomIt first, RandomIt last);

template<class RandomIt, class Compare>
void sort(RandomIt first, RandomIt last, Compare comp);

• first，last：指定排序范围的随机访问迭代器。
• comp：可选的比较器，定义元素顺序，默认为 std::less（基于 operator< 的升序排序）。
• 时间复杂度：平均和最坏情况均为 O(n log n)。
• 空间复杂度：通常为 O(log n)，用于递归栈或临时缓冲区。
• 要求：比较器必须满足严格弱序（strict weak ordering），否则可能导致未定义行为。

核心算法：内省排序（Introsort）

C++ 标准未强制指定 std::sort 的实现算法，但大多数现代标准库（如 libstdc++、libc++）采用 内省排序（Introsort）。

Introsort 由 David Musser 于 1997 年提出，是一种混合排序算法，结合了快速排序（Quicksort）、堆排序（Heapsort）和插入排序（Insertion Sort）的优点，以兼顾效率和鲁棒性。

1. 快速排序

快速排序是 Introsort 的主要算法，步骤如下：

• 选择基准（pivot）：通常使用三数取中（median-of-three，选取首、尾、中间元素的中位数）或随机选择。
• 分区（partition）：将元素分为小于等于基准和大于基准的两部分。
• 递归：对两个子区间递归排序。

特点：

• 平均时间复杂度：O(n log n)。
• 最坏情况（如已排序或逆序数组）：O(n²)。
• 优化：三数取中或随机化基准减少最坏情况概率。

实现细节：

• 分区方案：常用 Lomuto 或 Hoare 分区算法。
• 基准选择：三数取中避免极端情况（如已排序输入）。

2. 堆排序

当快速排序的递归深度超过阈值（通常为 2 * log n），Introsort 切换到堆排序，以避免快速排序的最坏情况。

步骤：

• 构建最大堆（或最小堆，取决于排序顺序）。
• 反复将堆顶元素移到末尾并调整堆。

特点：

• 时间复杂度：始终为 O(n log n)。
• 空间复杂度：O(1)（原地排序）。
• 适合处理快速排序退化的场景。

实现细节：

• 使用数组表示堆，通过下标计算父子节点关系。
• 堆调整（sift-down）确保堆性质。

3. 插入排序

当子区间大小较小时（通常 < 16 或 32 个元素，具体阈值依实现而定），Introsort 切换到插入排序。

步骤：

• 逐个将元素插入到已排序的子序列中。

特点：

• 时间复杂度：O(n²)，但在小数组上常数开销低。
• 适合部分有序或小规模数据。

实现细节：

• 通常通过循环实现，避免递归。
• 常用于优化小规模子区间的排序。

原因：

• 快速排序：平均性能优异，但在最坏情况下（如已排序或重复元素）退化为 O(n²)。
• 堆排序：保证最坏情况 O(n log n)，但平均性能稍逊，且堆调整开销较高。
• 插入排序：在小规模数据上高效，减少递归开销。 Introsort 动态切换算法，确保：
• 高效性：利用快速排序的平均性能。
• 鲁棒性：通过堆排序避免最坏情况。
• 优化性：插入排序处理小数组。

自定义排序

1. 函数指针

定义一个独立的比较函数，签名需为bool(T, T)：

bool compare(int a, int b) {
    return a > b; // 降序排序
}

std::vector<int> vec = {5, 2, 9, 1, 5};
std::sort(vec.begin(), vec.end(), compare); // 结果为 {9, 5, 5, 2, 1}

2. 静态成员函数

在类中定义静态比较函数，避免依赖对象实例：

class Sorter {
public:
    static bool compare(int a, int b) {
        return a > b; // 降序排序
    }
};

std::vector<int> vec = {5, 2, 9, 1, 5};
std::sort(vec.begin(), vec.end(), Sorter::compare);

注意：非静态成员函数因隐含this指针，签名不匹配std::sort的要求，因此无法直接使用。

3. 使用函数对象

通过定义一个类并重载operator()，可以在比较器中存储状态：

class Comparator {
    int threshold;
public:
    Comparator(int t) : threshold(t) {}
    bool operator()(int a, int b) const {
        return a > threshold && a < b; // 仅对大于threshold的元素降序排序
    }
};

std::vector<int> vec = {5, 2, 9, 1, 5};
std::sort(vec.begin(), vec.end(), Comparator(3));

4. 使用Lambda表达式（C++11及以上）

Lambda表达式提供了一种简洁的方式定义比较器，并可捕获外部变量：

int threshold = 3;
std::vector<int> vec = {5, 2, 9, 1, 5};
std::sort(vec.begin(), vec.end(), [threshold](int a, int b) {
    return a > threshold && a < b;
});

5.使用std::function

C++11引入的std::function可以包装任何可调用对象（包括函数指针、Lambda、函数对象等），提供更灵活的方式：

#include <functional>
std::function<bool(int, int)> comp = [](int a, int b) {
    return a > b; // 降序排序
};

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

适用场景：当需要在运行时动态选择比较器时，std::function非常有用，但会引入少量性能开销。

6.使用标准比较器（如std::greater、std::less）

C++标准库提供了预定义的比较器（如<functional>中的std::greater和std::less），可直接用于简单排序需求：

#include <functional>
std::vector<int> vec = {5, 2, 9, 1, 5};
std::sort(vec.begin(), vec.end(), std::greater<int>()); // 降序排序
std::sort(vec.begin(), vec.end(), std::less<int>());   // 升序排序

优点：无需手动定义比较器，代码简洁，适合常见升序或降序需求。

7.重载operator<

对于自定义结构体或类，可以通过重载operator<来定义默认排序规则，省去显式比较器：

struct Person {
    std::string name;
    int age;
    bool operator<(const Person& other) const {
        return age < other.age; // 按年龄升序
    }
};

std::vector<Person> people = {{"Alice", 25}, {"Bob", 30}, {"Charlie", 20}};
std::sort(people.begin(), people.end()); // 使用operator<，按年龄升序

适用场景：当类型有自然的排序规则且不需要多种排序方式时，重载operator<是最简洁的方案。

自定义结构体或类的排序

当排序对象是自定义结构体或类时，可以结合上述方法。

例如，使用Lambda：

std::vector<Person> people = {{"Alice", 25}, {"Bob", 30}, {"Charlie", 20}};

// 按名字字典序排序
std::sort(people.begin(), people.end(), [](const Person& a, const Person& b) {
    return a.name < b.name;
});

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

最新评论