排序的学问——c++各类排序算法介绍及代码实现-CSDN博客

本文链接：https://blog.csdn.net/imlarry0616/article/details/149004887

一、简单排序算法（O (n²) 复杂度）

适用于小规模数据（n<10³），实现简单但效率较低。

1. 冒泡排序（Bubble Sort）

原理：相邻元素比较，逆序时交换，每轮将最大元素 “冒泡” 到末尾。

代码示例：

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; ++i) {
        for (int j = 0; j < n-i-1; ++j) {
            if (arr[j] > arr[j+1]) swap(arr[j], arr[j+1]);
        }
    }
}

特点：
- 稳定排序（不改变相同元素相对顺序）。
- 最好情况 O (n)（已有序时可提前终止），最坏 / 平均 O (n²)。
- 竞赛场景：几乎不用，仅作为算法入门练习。

2. 插入排序（Insertion Sort）

原理：将元素逐个插入已排序区间，类似扑克牌整理。

代码示例：

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; ++i) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

特点：
- 稳定排序。
- 最好情况 O (n)，最坏 / 平均 O (n²)。
- 优化：用二分查找确定插入位置（二分插入排序），但时间复杂度仍为 O (n²)。
- 竞赛场景：小规模数据或部分有序数据（如链表排序）。

3. 选择排序（Selection Sort）

原理：每轮选择未排序部分的最小元素，与未排序起点交换。

代码示例：

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n-1; ++i) {
        int min_idx = i;
        for (int j = i+1; j < n; ++j) {
            if (arr[j] < arr[min_idx]) min_idx = j;
        }
        swap(arr[i], arr[min_idx]);
    }
}

特点：
- 不稳定排序（如序列 [5, 5, 3] 排序后相同元素顺序可能改变）。
- 无论是否有序，均需 O (n²) 时间（无优化空间）。
- 竞赛场景：极少使用，仅用于理解选择思想。

二、进阶排序算法（O (n log n) 复杂度）

适用于大规模数据（n≥10³），是竞赛核心内容。

4. 快速排序（Quick Sort）

原理：分治算法，选基准值（pivot），将数组划分为小于、等于、大于基准的三部分，递归排序。

代码示例（单基准版）：

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = arr[high]; // 选最后一个元素为基准
        int i = low - 1;
        for (int j = low; j < high; ++j) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr[i], arr[j]);
            }
        }
        swap(arr[i+1], arr[high]);
        quickSort(arr, low, i);
        quickSort(arr, i+2, high);
    }
}

特点：
- 不稳定排序。
- 平均时间 O (n log n)，最坏 O (n²)（可通过随机化基准或三数取中法优化）。
- 原地排序（空间 O (log n) 栈空间），效率高，是实际应用中最常用的排序算法之一。
- 竞赛场景：需手动实现时使用，注意处理边界情况（如大量重复元素）。

5. 归并排序（Merge Sort）

原理：分治算法，递归将数组分成两半，排序后合并（merge）。

代码示例（递归版）：

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1, n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; ++i) L[i] = arr[l+i];
    for (int j = 0; j < n2; ++j) R[j] = arr[m+1+j];
    int i=0, j=0, k=l;
    while (i < n1 && j < n2) {
        arr[k++] = (L[i] <= R[j]) ? L[i++] : R[j++];
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = L[j++];
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l)/2;
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        merge(arr, l, m, r);
    }
}

特点：
- 稳定排序。
- 时间复杂度稳定 O (n log n)，空间 O (n)（需额外数组存储临时合并结果）。
- 竞赛场景：适用于需要稳定排序或外排序（处理大文件）的场景，如归并树、逆序对统计等。

6. 堆排序（Heap Sort）

原理：利用堆结构（大根堆或小根堆），每次取出堆顶元素（最大 / 最小值），重建堆后重复操作。
步骤：
1. 构建大根堆（数组下标从 0 开始）。
2. 将堆顶（arr [0]）与末尾元素交换，缩小堆范围，调整堆结构。
3. 重复直到堆空。
特点：
- 不稳定排序。
- 时间 O (n log n)，空间 O (1)（原地排序，仅需常数额外空间）。
- 竞赛场景：适用于空间受限的情况，如操作系统内存管理，但实际竞赛中较少手动实现（可直接用 STL 优先队列）。

三、线性时间排序算法（非比较排序）

利用数据特性（如范围、位数）实现 O (n) 或 O (n+k) 复杂度，仅适用于特定数据类型。

7. 计数排序（Counting Sort）

原理：统计每个值的出现次数，按次数重建数组。
条件：数据范围有限（如已知最大值 max_val）。

代码示例：

void countingSort(int arr[], int n, int max_val) {
    vector<int> count(max_val+1, 0);
    for (int i=0; i<n; ++i) count[arr[i]]++;
    for (int i=1; i<=max_val; ++i) count[i] += count[i-1]; // 前缀和（确定元素位置）
    vector<int> output(n);
    for (int i=n-1; i>=0; --i) { // 稳定排序需从后往前遍历
        output[count[arr[i]]-1] = arr[i];
        count[arr[i]]--;
    }
    copy(output.begin(), output.end(), arr); // 复制回原数组
}

特点：
- 稳定排序。
- 时间 O (n + k)（k 为数据范围），空间 O (n + k)。
- 竞赛场景：处理整数且范围较小时（如 CSP-J 的 “推销员” 问题中排序分数）。

8. 基数排序（Radix Sort）

原理：按低位到高位（LSD）或高位到低位（MSD）依次排序，每次按某一位分组。
条件：数据为整数，且位数可分解（如十进制、二进制）。
示例：对数组按个位→十位→百位排序，每次用计数排序或桶排序。
特点：
- 稳定排序（取决于每轮排序的稳定性）。
- 时间 O (d (n + k))，d 为位数，k 为每一位的可能取值数（如十进制 k=10）。
- 竞赛场景：处理长整数或字符串排序（如 CSP-S 的 “交通规划” 中按编号排序）。

9. 桶排序（Bucket Sort）

原理：将数据分到有限个桶中，每个桶内单独排序，最后合并。
条件：数据分布均匀，可划分合理桶区间。
特点：
- 时间复杂度平均 O (n + m*(n/m log n/m)) = O (n log n)（m 为桶数），最坏仍可能退化为 O (n²)。
- 竞赛场景：处理浮点数或分布均匀的整数（如 NOI 的 “冗余路径” 问题）。

四、C++ 标准库排序：`std::sort`

实现：基于快速排序的优化版本（Introsort，内省排序），结合堆排序和插入排序。
特点：
- 自动处理递归深度，避免栈溢出。
- 对小规模数据（n<16）使用插入排序，提高常数效率。
- 不稳定排序，但可通过自定义结构体的operator<或传入比较函数实现复杂排序。

用法：

#include <algorithm>
vector<int> arr = {3, 1, 4, 1, 5, 9};
sort(arr.begin(), arr.end()); // 升序排序
sort(arr.begin(), arr.end(), greater<int>()); // 降序排序

// 结构体排序（按年龄升序，姓名字典序降序）
struct Student { string name; int age; };
bool cmp(Student a, Student b) {
    return a.age != b.age ? a.age < b.age : a.name > b.name;
}
sort(students.begin(), students.end(), cmp);

竞赛建议：
- 优先使用std::sort，其效率远超手动实现的排序算法。
- 若需稳定排序，可先用std::stable_sort（基于归并排序，时间 O (n log n)，空间 O (n)）。

五、算法对比与选择指南

算法	时间复杂度	空间复杂度	稳定性	适用场景
冒泡 / 插入 / 选择	O(n²)	O(1)	插入稳定	n<10³，简单场景
快速排序	平均 O (n log n)	O(log n)	不稳定	大规模通用排序（首选`std::sort`）
归并排序	O(n log n)	O(n)	稳定	需要稳定排序或外排序
堆排序	O(n log n)	O(1)	不稳定	空间受限或需要堆结构
计数 / 基数排序	O(n + k)	O(n + k)	稳定	整数且范围 / 位数有限

竞赛实战建议：

小规模数据：直接用插入排序或std::sort（效率足够）。
大规模通用排序：无脑用std::sort，搭配自定义比较函数。
特殊数据（如 0-1000 的整数）：用计数排序优化常数。
需稳定排序：用std::stable_sort或归并排序。

六、竞赛常见问题与优化

快速排序的最坏情况：
- 数据完全有序时，普通快排退化为 O (n²)，可通过随机化基准（random_shuffle）或三数取中法（选头、中、尾的中位数作为基准）避免。
排序与自定义类型：
- 对结构体排序时，优先重载operator<或使用 Lambda 表达式作为比较函数，确保逻辑正确（如避免浮点精度问题）。
稳定性的应用：
- 当排序关键字相同时需保留原顺序（如 “填数游戏” 中按分数排序后保持输入顺序），必须使用稳定排序算法。