排序算法及其时间复杂度比较
在C语言中，排序算法是常见的算法之一，用于将一组数据按照一定顺序排列。下面我将简要介绍几种常见排序算法的时间复杂度，并给出每种排序算法的C语言代码示例。
1. 插入排序（Insertion Sort）
时间复杂度：
- 平均和最坏情况：O(n^2)
- 最好情况：O(n)（当输入数组已经排序时）
代码示例：
#include <stdio.h>
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
/* 将arr[i]插入到已排序的序列arr[0..i-1]中的正确位置 */
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
printArray(arr, n);
}
}
// 测试代码
int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}
2. 选择排序（Selection Sort）
时间复杂度：
- 平均、最好、最坏情况：O(n^2)
代码示例：
#include <stdio.h>
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
void selectionSort(int arr[], int n) {
int i, j, min_idx, temp;
for (i = 0; i < n-1; i++) {
// 寻找[i, n-1]区间的最小值的索引下标
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
// 交换找到的最小元素与第i个元素
temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
printArray(arr, n);
}
}
// 测试代码
int main() {
int arr[] = {12, 11, 13, 5, 6,7,8};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}
3. 冒泡排序（Bubble Sort）
时间复杂度：
- 平均和最坏情况：O(n^2)
- 最好情况：O(n)（当输入数组已经排序时）
代码示例：
#include <stdio.h>
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
void bubbleSort(int arr[], int n) {
int i, j, temp;
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
printArray(arr, n);
}
}
// 测试代码
int main() {
int arr[] = {10, 14, 11, 5, 6,7,8};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}
4. 希尔排序（Shell Sort）
时间复杂度：
- 平均：取决于增量序列，O(nlogn)到O(n^2)
- 最坏情况：O(n^s)，其中s是所选用的增量序列中最大的增量
代码示例（使用简单的增量序列）：
#include <stdio.h>
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
void shellSort(int arr[], int n) {
for (int gap = n/2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i += 1) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
printArray(arr, n);
}
}
// 测试代码
int main() {
int arr[] = {11, 13, 12, 1, 3,9,8};
int n = sizeof(arr) / sizeof(arr[0]);
shellSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}
5. 快速排序（Quick Sort）
时间复杂度：
- 平均：O(n log n)
- 最好情况：O(n log n)
- 最坏情况：O(n^2)（当输入数组已经排序时）
代码示例（使用递归）：
#include <stdio.h>
void swap(int *xp, int *yp) {
int temp = *xp;
*xp = *yp;
*yp = temp;
}
int partition(int arr[], int low, int high) {
int pivot = arr[high]; // 选择最后一个元素作为基准
int i = (low - 1); // 较小元素的索引
for (int j = low; j <= high - 1; j++) {
// 如果当前元素小于或等于基准
if (arr[j] <= pivot) {
i++; // 增加较小元素的索引
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
/* pi 是分区后基准的正确位置 */
int pi = partition(arr, low, high);
// 递归地对基准前后的子数组进行排序
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 实用函数，用于打印数组
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
// 测试快速排序
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
6. 归并排序（Merge Sort）
时间复杂度：
- 平均、最好、最坏情况：O(n log n)
代码示例（使用递归）：
#include <stdio.h>
#include <stdlib.h>
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
// 创建临时数组
int L[n1], R[n2];
// 拷贝数据到临时数组
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
// 合并临时数组回到原数组arr[l..r]
i = 0; // 初始索引第一个子数组
j = 0; // 初始索引第二个子数组
k = l; // 初始索引被合并的子数组
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
// 拷贝L[]的剩余元素
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// 拷贝R[]的剩余元素
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
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);
}
}
// 实用函数，用于打印数组
void printArray(int arr[], int size) {
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
// 测试归并排序
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int arr_size = sizeof(arr) / sizeof(arr[0]);
printf("Given array is \n");
printArray(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array is \n");
printArray(arr, arr_size);
return 0;
}
在上述的几种排序算法中，各排序算法在各种情况中，运行时间的快慢都不一样，而在其中相较于一般情况，归并列算法相当于有不错的表现，而对于各时间复杂度下的快慢，本人列了一张表格，由快到慢（表格由上至下）如图表所示，所以在不同的数据处理场景中可以相对数据以及各硬件速度选择不同的排序算法，以达到程序的最优解。
理解和分析算法的时间复杂度是算法设计、优化和选择中的重要环节。通过比较不同算法的时间复杂度，我们可以评估它们在处理大规模数据时的效率和可行性。
| 名称 | 时间复杂度 |
|---|---|
| 常数时间 | O(1) |
| 对数时间 | O( log n) |
| 线性时间 | O(n ) |
| 线性对数时间 | O(n log n) |
| 二次时间 | O(n^2) |
| 三次时间 | O(n^3) |
| 指数时间 | O(2^n) |