高等排序_學習筆記

歸併排序

• 對整個陣列進行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；