各种排序算法代码

输入:

int a[10] = { 3, 2, 5, 9, 0, 7, 1, 6, 5, 4 };
void swap(int *a,int *b){
    *a^=*b;
    *b^=*a;
    *a^=*b;
}

一、选择排序

核心代码为：

    for (int i = 0; i < 9; i++){
        int min = a[i];
        for (int j = i + 1; j < 10; j++){
            if (min > a[j]){
                swap(&min, &a[j]);
            }
        }
        a[i] = min;
    }

二、希尔排序

希尔排序是基于插入排序的以下两点性质而改进的：
1.插入排序对几乎排好序的数据操作时，效率高，可达O(n)。
2.插入排序效率低，每次排序只能将数据移动一位。
核心代码：

    int length = 10;
    for (int len = length/2; len>=1; len--){
        for (int i = len; i < length; i++){
            int j = i - len;
            while (j >= 0 && a[j] > a[i]){
                swap(&a[i], &a[j]);
                j -= len;
            }
        }
    }

三、冒泡排序

冒泡排序可以原地排序，比较次数为$O(n^2)$。

    bool isSorted = false;
    for (int i = 0; i < 9; i++){
        if (isSorted) break;
        isSorted = true;
        int j=0;
        for (; j < 8 - i; j++){
            if (a[j]>a[j + 1]){
                swap(&a[j], &a[j + 1]);
                isSorted = false;
            }
        }
        //为了可能减少的最后一次比较，把最后两个元素的比较移除for
        if (a[j] > a[j+1]){
            swap(&a[j], &a[j+1]);
            isSorted = false;
        }
        else
            i++;
    }

四、快速排序

快速排序是由东尼-霍尔发展的一种排序算法。在平均情况下为O(nlogn)次比较，最坏时需要$O(n^2)$次比较。
事实上，快速排序通常比其他排序算法快，因为其内部排序可以在大部分架构上很有效的被实现。

void quickSort(int *data, int start, int end){//[start,end)
    if (start >= end) return;
    int low = start;
    int high = end;
    int pivot = data[low];
    while (low < high){
        while (low < high && data[--high] >= pivot);
        data[low] = data[high];
        while (low < high && data[++low] <= pivot);
        data[high] = data[low];
    }
    data[low] = pivot;
    quickSort(data, start, low);//[start,end)
    quickSort(data, low + 1, end);//[start,end)

}

五、归并排序

归并排序是分治算法的经典案例。

void mergeSort(int *data, int start, int end){//[start,end)
    if (start+1>= end) return;
    int low = start;
    int mid = (end + start) / 2;
    int high = end;
    mergeSort(data, low, mid);//[start,end)
    mergeSort(data, mid, high);//[start,end)
    int i = low;
    int j = mid;
    int *temp = new int[end - start];
    int k = 0;
    while (i < mid&&j < high){
        if (data[i] < data[j]) temp[k++] = data[i++];
        else temp[k++] = data[j++];
    }
    while (i < mid) temp[k++] = data[i++];
    while (j < high) temp[k++] = data[j++];
    memcpy(data + start, temp, sizeof(int)*(end - start));
    delete[]temp;
}

六、插入排序

    for (int i = 1; i < 10; i++){
        int j = i;
        while (j>0 && a[j] < a[j - 1])
        {
            swap(&a[j], &a[j - 1]);
            j--;
        }
    }