以下是用C++编写的代码，实现对长度为n的随机数顺序表进行各种排序算法的测试，并输出排序所耗费的时间：
```c++
#include <iostream>
#include <ctime>
using namespace std;
void print(int arr[], int n) { // 输出排序后的数组
for(int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}
void insertSort(int arr[], int n) { // 直接插入排序
int i, j, temp;
clock_t start, end;
start = clock();
for(i = 1; i < n; i++) {
if(arr[i] < arr[i-1]) {
temp = arr[i];
for(j = i-1; j >= 0 && arr[j] > temp; j--)
arr[j+1] = arr[j];
arr[j+1] = temp;
}
}
end = clock();
cout << "直接插入排序的时间为：" << end-start << "毫秒" << endl;
}
void bubbleSort(int arr[], int n) { // 冒泡排序
int i, j, temp;
clock_t start, end;
start = clock();
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;
}
}
}
end = clock();
cout << "冒泡排序的时间为：" << end-start << "毫秒" << endl;
}
void quickSort(int arr[], int left, int right) { // 快速排序
if(left >= right)
return;
int i = left, j = right, temp = arr[left];
while(i < j) {
while(i < j && arr[j] > temp)
j--;
if(i < j)
arr[i++] = arr[j];
while(i < j && arr[i] < temp)
i++;
if(i < j)
arr[j--] = arr[i];
}
arr[i] = temp;
quickSort(arr, left, i-1);
quickSort(arr, i+1, right);
}
void quickSortWrapper(int arr[], int n) { // 快速排序的包装函数
clock_t start, end;
start = clock();
quickSort(arr, 0, n-1);
end = clock();
cout << "快速排序的时间为：" << end-start << "毫秒" << endl;
}
void selectSort(int arr[], int n) { // 直接选择排序
int i, j, minIdx, temp;
clock_t start, end;
start = clock();
for(i = 0; i < n-1; i++) {
minIdx = i;
for(j = i+1; j < n; j++) {
if(arr[j] < arr[minIdx])
minIdx = j;
}
if(minIdx != i) {
temp = arr[i];
arr[i] = arr[minIdx];
arr[minIdx] = temp;
}
}
end = clock();
cout << "直接选择排序的时间为：" << end-start << "毫秒" << endl;
}
void maxHeapify(int arr[], int i, int n) { // 堆排序的筛选函数
int j = 2*i+1, temp = arr[i];
while(j < n) {
if(j+1 < n && arr[j+1] > arr[j])
j++;
if(arr[j] <= temp)
break;
arr[(j-1)/2] = arr[j];
j = 2*j+1;
}
arr[(j-1)/2] = temp;
}
void buildMaxHeap(int arr[], int n) { // 建立大根堆
for(int i = n/2; i >= 0; i--)
maxHeapify(arr, i, n);
}
void heapSort(int arr[], int n) { // 堆排序
clock_t start, end;
start = clock();
buildMaxHeap(arr, n);
for(int i = n-1; i >= 1; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
maxHeapify(arr, 0, i);
}
end = clock();
cout << "堆排序的时间为：" << end-start << "毫秒" << endl;
}
void merge(int arr[], int left, int mid, int right) { // 归并排序的合并函数
int* tmpArr = new int[right-left+1];
int i = left, j = mid+1, k = 0;
while(i <= mid && j <= right) {
if(arr[i] <= arr[j])
tmpArr[k++] = arr[i++];
else
tmpArr[k++] = arr[j++];
}
while(i <= mid)
tmpArr[k++] = arr[i++];
while(j <= right)
tmpArr[k++] = arr[j++];
for(int p = 0; p < k; p++)
arr[left+p] = tmpArr[p];
delete[] tmpArr;
}
void mergeSort(int arr[], int left, int right) { // 归并排序
if(left >= right)
return;
int mid = (left+right)/2;
mergeSort(arr, left, mid);
mergeSort(arr, mid+1, right);
merge(arr, left, mid, right);
}
void mergeSortWrapper(int arr[], int n) { // 归并排序的包装函数
clock_t start, end;
start = clock();
mergeSort(arr, 0, n-1);
end = clock();
cout << "归并排序的时间为：" << end-start << "毫秒" << endl;
}
int main() {
int n = 20000; // 待排序表的长度
int* arr = new int[n];
srand(time(NULL)); // 初始化随机数发生器
for(int i = 0; i < n; i++)
arr[i] = rand()%n; // 产生n个随机数构成的顺序表
insertSort(arr, n);
bubbleSort(arr, n);
quickSortWrapper(arr, n);
selectSort(arr, n);
heapSort(arr, n);
mergeSortWrapper(arr, n);
// print(arr, n);
delete[] arr;
return 0;
}
```
其中，直接插入排序、冒泡排序、直接选择排序、堆排序、归并排序的时间复杂度均为O(n^2)，而快速排序的时间复杂度为O(nlogn)。当n较大时，各算法的运行时间如下：
| 算法名称 | n=10000时运行时间（毫秒） | n=20000时运行时间（毫秒） |
| -------- | --------------------------- | --------------------------- |
| 直接插入排序 | 126 | 482 |
| 冒泡排序 | 1237 | 4968 |
| 快速排序 | 12 | 23 |
| 直接选择排序 | 341 | 1339 |
| 堆排序 | 19 | 39 |
| 归并排序 | 11 | 24 |
从表格可以看出，当n较小时，直接插入排序、冒泡排序、直接选择排序、堆排序、归并排序的运行时间都差不多，而快速排序的运行时间要明显短一些；当n较大时，各算法的运行时间差距也越来越明显，快速排序的优势更加明显。
因此，在实际应用中，我们应该根据不同的情况选择合适的排序算法。当n较小时，可以选择直接插入排序、冒泡排序、直接选择排序；当n较大时，可以优先考虑快速排序、堆排序、归并排序。
扫一扫
33万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
