C语言算法：线性时间排序

原创已于 2025-11-11 19:09:05 修改 · 1.4k 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c语言 #排序算法 #线性时间排序 #计数排序 #桶排序 #基数排序

于 2025-11-11 18:15:22 首次发布

C语言算法基础专栏收录该内容

16 篇文章

订阅专栏

本文献给：
想要掌握线性时间复杂度排序算法的C语言程序员。如果你已经了解了比较排序，想要学习在特定条件下达到O(n)时间复杂度的排序方法——本文将带你深入理解计数排序、桶排序和基数排序的原理与实现。

你将学到：

理解线性时间排序算法的适用条件和原理
掌握计数排序的实现和优化技巧
掌握桶排序的分桶策略和合并方法
掌握基数排序的位处理技术
学会在不同数据特征下选择合适的线性排序算法

让我们开始探索线性时间排序算法的精妙世界！

第一部分：线性时间排序概述
- 1. 比较排序的极限与突破
- 2. 线性排序的适用场景
第二部分：计数排序
- 1. 计数排序基本原理
- 2. 计数排序的优化技巧
第三部分：桶排序
- 1. 桶排序基本原理
- 2. 桶排序的性能分析
第四部分：基数排序
- 1. LSD基数排序原理
- 2. MSD基数排序与字符串排序
第五部分：三种算法对比与选择
- 1. 性能特征对比
- 2. 算法选择指南
第六部分：总结
- 核心要点总结
第七部分：常见问题解答

第一部分：线性时间排序概述

1. 比较排序的极限与突破

在之前的学习中，我们了解的排序算法（快速排序、归并排序、堆排序）都是基于比较的排序，它们的时间复杂度下界是O(n log n)，但有些排序算法通过利用数据的特定属性，可以突破这个限制！这些算法不依赖于元素间的比较，而是利用数据本身的特性，在特定条件下达到O(n)的时间复杂度。

为什么能够突破O(n log n)的限制？

计数排序：利用数据范围有限的特性
桶排序：利用数据均匀分布的假设
基数排序：利用数据可按位处理的特性

这些算法之所以能达到线性时间复杂度，是因为它们放弃了通用的比较策略，转而利用数据的特殊性质来获得性能优势。

2. 线性排序的适用场景

线性时间排序算法并非万能，它们只在特定条件下才能发挥优势。理解这些条件对于正确选择算法至关重要。

计数排序适用条件：

数据范围已知且相对较小（k ≈ n）
数据为整数或可映射为整数
需要稳定排序

桶排序适用条件：

数据均匀分布在某个范围内
数据为浮点数或可划分区间
可以接受最坏情况O(n²)的时间复杂度

基数排序适用条件：

数据可以按位或按字符分割
数据范围较大但位数固定
需要稳定排序

实际应用举例：

考试成绩排序（计数排序）
年龄统计（计数排序）
均匀分布的随机数（桶排序）
字符串字典序排序（基数排序）
大整数排序（基数排序）

第二部分：计数排序

1. 计数排序基本原理

计数排序的核心思想是：通过统计每个元素出现的次数，然后计算每个元素在输出数组中的位置。

算法步骤：

统计频率：遍历数组，统计每个元素出现的次数
计算位置：计算每个元素的累积频率，确定其在输出数组中的位置
构建输出：根据位置信息将元素放到输出数组的正确位置

关键特点：

稳定性：通过从后往前遍历输入数组来保证稳定性
空间复杂度：O(k)，k为数据范围
时间复杂度：O(n + k)

// 计数排序核心实现
void countingSort(int arr[], int n) {
    // 找出最大值确定数据范围
    int max = findMax(arr, n);
    
    // 创建计数数组
    int *count = (int*)calloc(max + 1, sizeof(int));
    int *output = (int*)malloc(n * sizeof(int));
    
    // 统计每个元素的出现次数
    for (int i = 0; i < n; i++) {
        count[arr[i]]++;
    }
    
    // 计算累积频率（位置信息）
    for (int i = 1; i <= max; i++) {
        count[i] += count[i - 1];
    }
    
    // 构建输出数组（从后往前保证稳定性）
    for (int i = n - 1; i >= 0; i--) {
        output[count[arr[i]] - 1] = arr[i];
        count[arr[i]]--;
    }
    
    // 复制回原数组
    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
    
    free(count);
    free(output);
}

2. 计数排序的优化技巧

处理负数：
通过数据偏移将负数映射到非负数范围，排序后再映射回去。

void countingSortWithNegative(int arr[], int n) {
    int min = findMin(arr, n);
    int max = findMax(arr, n);
    int range = max - min + 1;
    
    // 创建计数数组，考虑负数偏移
    int *count = (int*)calloc(range, sizeof(int));
    int *output = (int*)malloc(n * sizeof(int));
    
    // 统计频率（考虑偏移）
    for (int i = 0; i < n; i++) {
        count[arr[i] - min]++;
    }
    
    // 后续步骤类似...
}

内存优化：
当数据范围很大但数据很稀疏时，可以使用哈希表代替数组来存储计数。

应用场景优化：

小范围整数排序：直接使用基础计数排序
考试成绩排序：范围固定为0-100，效率极高
年龄统计：范围0-150，适合计数排序

第三部分：桶排序

1. 桶排序基本原理

桶排序的核心思想是：将数据分到有限数量的桶里，每个桶再分别排序，最后合并结果。

算法步骤：

分桶：创建空桶，根据映射函数将元素分配到对应的桶中
桶内排序：对每个非空桶进行排序（通常使用插入排序）
合并结果：按顺序将各个桶中的元素合并

关键特点：

平均时间复杂度：O(n + k)，k为桶的数量
最坏时间复杂度：O(n²)，当所有元素都集中在一个桶中时
空间复杂度：O(n + k)

// 桶排序基本结构
void bucketSort(double arr[], int n) {
    // 创建n个空桶
    Node** buckets = createBuckets(n);
    
    // 将元素分配到桶中
    for (int i = 0; i < n; i++) {
        int bucketIndex = n * arr[i];  // 假设数据在[0,1)范围内
        insertToBucket(buckets[bucketIndex], arr[i]);
    }
    
    // 对每个桶排序
    for (int i = 0; i < n; i++) {
        sortBucket(buckets[i]);
    }
    
    // 合并桶
    mergeBuckets(buckets, arr, n);
}

2. 桶排序的性能分析

理想情况：
当数据均匀分布时，每个桶包含大约n/k个元素。如果使用O(m log m)的排序算法对桶内元素排序，总时间复杂度为：

O(n + k × (n/k) log(n/k)) = O(n + n log(n/k))

当k ≈ n时，时间复杂度接近O(n)。

最坏情况：
当所有元素都分配到同一个桶中时，桶排序退化为单个桶的排序算法。如果使用插入排序，最坏时间复杂度为O(n²)。

影响因素：

数据分布：均匀分布时性能最好
桶的数量：桶太少导致桶内元素过多，桶太多导致额外开销
桶内排序算法：影响常数因子

优化策略：

自适应分桶：根据数据分布动态调整桶的数量和范围
桶内算法选择：对小桶使用插入排序，对大桶使用快速排序
空桶处理：跳过空桶减少不必要的操作

第四部分：基数排序

1. LSD基数排序原理

LSD（Least Significant Digit）基数排序从最低位开始，依次按每一位进行排序。

算法步骤：

找出最大位数：确定需要排序的轮数
按位排序：从最低位到最高位，每一轮使用稳定的排序算法（通常是计数排序）按当前位排序
重复直到最高位：完成所有位的排序后，数组整体有序

关键特点：

稳定性：每轮使用稳定排序算法保证整体稳定性
时间复杂度：O(nk)，k为最大位数
空间复杂度：O(n + k)

// LSD基数排序实现
void radixSortLSD(int arr[], int n) {
    int max = findMax(arr, n);
    
    // 计算最大位数
    int maxDigits = countDigits(max);
    
    // 从最低位到最高位依次排序
    for (int digit = 0; digit < maxDigits; digit++) {
        countingSortByDigit(arr, n, digit);
    }
}

2. MSD基数排序与字符串排序

MSD（Most Significant Digit）基数排序从最高位开始排序，采用分治策略。

与LSD的区别：

排序方向：MSD从高位到低位，LSD从低位到高位
策略：MSD采用分治，LSD采用迭代
适用场景：MSD适合变长数据，LSD适合等长数据

字符串排序应用：
基数排序天然适合字符串的字典序排序，可以看作是多关键字的排序问题。

// 字符串基数排序
void stringRadixSort(char *strings[], int n, int maxLen) {
    // 从最后一个字符到第一个字符排序
    for (int pos = maxLen - 1; pos >= 0; pos--) {
        countingSortByChar(strings, n, pos);
    }
}

性能考虑：

缓存性能：LSD顺序访问内存，缓存友好
递归开销：MSD使用递归，可能有额外开销
实现复杂度：MSD实现相对复杂

第五部分：三种算法对比与选择

1. 性能特征对比

特性	计数排序	桶排序	基数排序
时间复杂度	O(n + k)	平均O(n + k)，最坏O(n²)	O(nk)
空间复杂度	O(k)	O(n + k)	O(n + k)
稳定性	是	取决于桶内排序	是
数据要求	范围小的整数	均匀分布	可按位分割
适用场景	小范围整数	均匀分布浮点数	字符串、大整数