几种排序的比较

#include <iostream>
#include <time.h>
#include <locationapi.h>
using namespace std;
const int N = 1e6;
time_t Now() {
    time_t second;
    time(&second);
    SYSTEMTIME ms;
    GetSystemTime(&ms);
    return second * 1000 + ms.wMilliseconds;
}
void init(int a[], int n) {
    srand(time(NULL));
    for (int i = 0; i < n; i++) {
        a[i] = rand();
    }
}
void check(int a[], int n) {
    for (int i = 1; i < n; i++) {
        if (a[i] < a[i - 1]) {
            printf("error");
            return;
        }
    }
    printf("finish");
}
// 把a[parent]为根的堆调整为大顶堆
void heapAdjust(int a[], int parent, int n) { // 2*i+1  2*i+2
    int top = a[parent];
    while (parent * 2 + 1 < n) {
        int child = parent * 2 + 1;
        if (child + 1 < n && a[child + 1] > a[child]) {
            child++;
        }
        if (top >= a[child]) {
            break;
        }
        a[parent] = a[child];
        parent = child;
    }
    a[parent] = top;
}
void heapSort(int a[], int n) {
    int i;
    for (i = n / 2 - 1; i >= 0; i--) {
        heapAdjust(a, i, n);
    }
    for (i = n - 1; i > 0; i--) {
        int t = a[i];
        a[i] = a[0];
        a[0] = t;
        heapAdjust(a, 0, i);
    }
}
void InsertSort(int a[], int n) { // 简单插入排序
    int i, j;
    for (i = 1; i < n; i++) {
        int t = a[i]; // 取未排序的第一个元素
        for (j = i; j >= 1 && a[j - 1] > t; j -= 1) { // 依次与已排序的元素比较
            a[j] = a[j - 1]; // 右移，为该元素空出插入的位置
        }
        a[j] = t; // 插入该元素
    }
}
void bSort(int a[], int n) { // 冒泡
    int i, j, t;
    for (i = 0; i < n - 1; i++) {
        int sorted = 1;
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                sorted = 0;
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
        if (sorted) {
            break;
        }
    }
}
void ShellSort(int a[], int n) { // 希尔排序
    int gap = n >> 1; // 增量
    while (gap > 0) {
        int i, j;
        // 对每一个子序列进行插入排序
        for (i = gap; i < n; i++) {
            int t = a[i]; // 取当前子序列中未排序的第一个元素
            for (j = i; j >= gap && a[j - gap] > t; j -= gap) { // 依次与当前子序列中已排序的元素比较
                a[j] = a[j - gap]; // 右移，为该元素空出插入的位置
            }
            a[j] = t; // 插入该元素
        }
        gap >>= 1;
    }
}
void changeFirst(int a[], int left, int right) {
    int i = left + rand() % (right - left);
    int t = a[left];
    a[left] = a[i];
    a[i] = t;
}
int getP(int a[], int left, int right) { // 快排
    changeFirst(a, left, right);
    int k = a[left], i, index = left;
    for (i = left + 1; i <= right; i++) {
        if (a[i] < k) {
            index++;
            int t = a[i];
            a[i] = a[index];
            a[index] = t;
        }
    }
    a[left] = a[index];
    a[index] = k;
    return index;
}
void quickSort(int a[], int left, int right) {
    if (left < right) {
        int mid = getP(a, left, right);
        quickSort(a, left, mid - 1);
        quickSort(a, mid + 1, right);
    }
}
int a[N] = {0};
int main() {
    init(a, N);
    time_t start = Now();
    // quickSort(a, 0, N - 1);
    // ShellSort(a, N);
    heapSort(a, N);
    printf("\nuse: %lld ms\n", Now() - start);
    check(a, N);
    return 0;
}

当N=1e6，数组元素随机时，

• 堆排序约200ms
• 希尔排序约270ms
• 快速排序约170ms
• 插入排序。。。

当N=1e6，数组元素有序或基本有序时，

• 堆排序约120ms
• 希尔排序约50ms
• 快速排序约140ms
• 插入排序约3ms

当N=1e6，数组元素全部相同时，

• 堆排序约10ms
• 希尔排序约50ms
• 快速排序。。。
• 插入排序约3ms