Sort (1) -- 常用排序

插入排序 -- O(n ^ 2)

每次保证前i-1个元素是有序，然后将i个元素插入到正确的位置。

void insertSort(int A[],int left, int right){
    for(int i = left + 1; i <= right; i++){
     int tmp = A[i];
     int j = i;
     for(; j > left && A[j - 1] > tmp; j--){ //如果比a[i]大，则将元素向后移一位
        A[j] = A[j-1];
     }
     A[j] = tmp;
    }
}

希尔排序 -- (O(n ^ 2), O(n ^ (3/2)))

使用了一个增量序列的插入排序。每次保证第i - increment, i - 2 * increment...序列是有序的。下面采用n / 2序列。关于shell排序的增量序列有专门的研究工作，如 Sedgewick, Hibbard。

void shellSort(int A[], int n){
    for(int increment = n / 2; increment > 0; increment /= 2){
        for(int i = 1; i < n; i += increment){
            int tmp = A[i];
            int j = i;
            for(; j >= increment && A[j - increment] > tmp; j -= increment){
                A[j] = A[j-increment];
            }
            A[j] = tmp;
        }
    }
}

堆排序 -- O(nlogn)

1. 在最大堆中，每个结点的儿子都小于它本身；最小堆中，每个结点的儿子都大于它本身。

2. 建立一个最大堆，然后每次将最大值删除并放在数组的尾部，避免使用多余的空间。

3. 堆的平均性能比较稳定

void precDown(int A[], int i, int n){
    int child = 2 * i + 1;  //在堆中，第i个元素的左儿子为 2 * i + 1，右儿子为 2 * i + 2
    int tmp = A[i];  //被检查的
    while(child < n){
        if(child + 1 < n && A[child] < A[child+1])  //choose larger child
            child++;
        if(tmp < A[child]) A[i] = A[child];  //与儿子结点进行比较
        else break;
        i = child;
        child = 2 * i + 1;
    }
    A[i] = tmp;
}
void heapSort(int A[], int n){

    //建立堆。从堆中的最后一个非叶子结点开始，我们默认所有的叶子结点都是有效堆
    for(int i = n / 2; i >= 0; i--){ 
        precDown(A, i, n);  
    }

    //deleteMax操作
    for(int i = n - 1; i > 0; i--){
        swap(A[i], A[0]);
        precDown(A, 0, i);
    }
}

归并排序 -- O(nlogn)

归并排序是一个将数组不断分割并合并两个有序数组的过程。我们将数组最小分割至元素个数为1，即相当于当于简单的比较两个元素。

//合并两个有序数组,使用一个tmp数组存储临时结果，复杂度为O(n)
void mergeA(int a[], int tmpA[], int left, int mid, int right){
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] < a[j]) tmpA[k++] = a[i++];
        else tmpA[k++] = a[j++];
    }
    while(i <= mid) tmpA[k++] = a[i++];
    while(j <= right) tmpA[k++] = a[j++];
    for(int m = left; m <= right; m++)   //将合并后的结果复制到原数组
        a[m] = tmpA[m];
}

void mSort(int a[], int tmpA[],int left, int right){ int mid = (left + right) / 2; if(left >= right) return; //注意这里的临界条件 mSort(a, tmpA, left, mid); mSort(a, tmpA, mid+1, right); mergeA(a, tmpA, left, mid, right);}void mergeSort(int a[], int n){ int tmpA[n]; mSort(a, tmpA, 0, n-1);}

快速排序 -- O(nlogn)

1. 每次选择一个枢纽点，调整元素顺序使得枢纽点左边都是小于枢纽点的元素，枢纽点右边都是大于枢纽点的元素，这样枢纽点所在的位置即为正确位置。

2. 使用三值中位法可以节省5%的时间

3. 当i和j遇到等于枢纽点的值时也进行交换，这样做的结果是可以尽量得到元素数目相近的两个子序列。

int median3(int a[], int left, int right){
    int mid = (left + right) / 2;
    if(a[left] > a[mid])
        swap(a[left], a[mid]);
    if(a[left] > a[right])
        swap(a[left], a[right]);
    if(a[mid] > a[right])
        swap(a[mid], a[right]);
    swap(a[mid], a[right-1]);  //pivot放在末尾的前一位，第一位是小于pivot的，最后一位是大于pivot的，这样可以安全的对[left + 1, right - 2]进行排序
    return a[right-1];
}

//一次快排将一个元素放置在正确的位置
void quickSort(int a[], int left, int right){
    int cutoff = 3;
    if(right - left + 1 >= cutoff){   //元素数量大于等于3时才使用快排
        int pivot = median3(a, left, right);
        int i = left, j = right - 1;
        while(true){
            while(a[++i] < pivot);  //注意a[i] = a[j] = pivot的情形，要先加减再比较
            while(a[--j] > pivot);
            if(i < j) swap(a[i], a[j]);
            else break;
        }
        swap(a[i], a[right-1]); //i是pivot的正确位置
        quickSort(a, left, i - 1);
        quickSort(a, i + 1, right);
    }
    else
        insertSort(a, left, right);

}