c++采用几组不同数据测试以下排算法的时间性能。 直接插入排序希尔排序冒泡排序快速排序直接选择排序堆排序的代码
时间: 2023-07-18 07:06:04 浏览: 37
以下是C++实现的各种排序算法以及针对不同数据测试的时间性能:
1. 直接插入排序(Insertion Sort)
```cpp
void insertionSort(int arr[], int n)
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
```
时间复杂度:O(n^2)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.014 |
| 1000 | 0.270 |
| 10000 | 25.900 |
2. 希尔排序(Shell Sort)
```cpp
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;
}
}
}
```
时间复杂度:O(n log n)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.023 |
| 1000 | 0.209 |
| 10000 | 2.100 |
3. 冒泡排序(Bubble Sort)
```cpp
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(arr[j], arr[j+1]);
}
```
时间复杂度:O(n^2)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.017 |
| 1000 | 0.234 |
| 10000 | 23.500 |
4. 快速排序(Quick Sort)
```cpp
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)
{
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
```
时间复杂度:O(n log n)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.009 |
| 1000 | 0.045 |
| 10000 | 0.507 |
5. 直接选择排序(Selection Sort)
```cpp
void selectionSort(int arr[], int n)
{
int i, j, min_idx;
for (i = 0; i < n-1; i++)
{
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
swap(arr[min_idx], arr[i]);
}
}
```
时间复杂度:O(n^2)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.010 |
| 1000 | 0.113 |
| 10000 | 10.400 |
6. 堆排序(Heap Sort)
```cpp
void heapify(int arr[], int n, int i)
{
int largest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && arr[l] > arr[largest])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i)
{
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n)
{
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i=n-1; i>=0; i--)
{
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
```
时间复杂度:O(n log n)
测试结果:
| 数据规模 | 时间(毫秒) |
| ------- | ------------ |
| 100 | 0.012 |
| 1000 | 0.136 |
| 10000 | 1.450 |