高等排序_学习笔记

高等排序_学习笔记

归并排序

• 对整个数组进行mergeSort;
• mergeSort的步骤如下：
  • 将给定的包括n个元素的局部数组“分割”成两个局部数组，每个数组各包括n/2各元素:(devide)；
  • 对两个局部数组分别执行mergeSort排序。(solve)；
  • 通过merge将两个已排序完毕的局部数组整合成一个数组；

merge处理是这样的，由于两个待处理的局部数组都完成了排序，因此可以采用复杂度为O(n1+n2)的合并算法：

#include <iostream>
using namespace std;

#define MAX 500000
#define INFTY 200000000000

void merge(int A[], int n, int left, int mid, int right) {
    int n1 = mid-left, n2 = right-mid;
    int L[MAX/2+2], R[MAX/2+2];
    for (int i=0; i<n1; i++) L[i] = A[left+i];
    for (int i=0; i<n2; i++) R[i] = A[mid+i];
    L[n1] = R[n2] = INFTY;
	int i=0, j=0;
    for (int k=left; k<right; k++) {
        if (L[i]<=R[j]) A[k] = L[i++];
        else A[k] = R[j++];   
    }
}
void mergeSort(int A[], int n, int left, int right) {
    if (left+1<right) {
        int mid = (left+right)/2;
        mergeSort(A, n, left, mid);
        mergeSort(A, n, mid, right);
        merge(A, n, left, mid, right);
    }
}

• 归并排序是稳定排序，复杂度为O(nlongn);

快速排序

• 以整个数组为对象执行quickSort；
• quickSort流程如下：
  • 通过分割将对象局部数组分割为前后两个局部数组；
  • 对前半部分的局部数组执行quickSort；
  • 对后半部分的局部数组执行quickSort；

int partition(int p, int r) {
    int x, i, j, t;
    x = A[r];
    i = p-1;
    for (j=p; j<r; j++) {
        if (A[j]<=x) {
            i++;
            t = A[i]; A[i] = A[j]; A[r] = t;
        }
    }
    t = A[i+1]; A[i+1] = A[r]; A[r] = t;
    return i+1;
}
void quickSort(int A[], int n, int p, int r) {
    int q;
    if (p<r) {
        q = partition(A, n, p, r);
        quickSort(A, n, p, q-1);
        quickSort(A, n, q+1, r);
    }
}

• 快速排序平均复杂度为O(nlogn)，是不稳定排序；

利用标准库排序

• 快速排序函数：sort；
• 归并排序函数：stable_sort；