快速排序

快速排序算法
O（N*logN）

//插入排序  从小到大排序
template<typename T>
void InsertionSort(T *A, int N){
    int j, p;
    T tmp;
    for (p = 1; p < N; p++){
        tmp = A[p];
        for (j = p; j>0 && A[j-1] > tmp; j--){
            A[j] = A[j - 1];
            A[j - 1] = tmp;
        }
    }
}



//快速排序

const int CutOff = 3;  //截止范围，用来处理小数组。可以大于3
//对于很小的数组，快速排序不如插入排序好。
//也避免了一些有害的特殊情形，如“三数中值分割法”的实际只有一个或两个元素的情况。

//快速排序的驱动程序
template<typename T>
void QuickSort(T A[], int N){

    Qsort(A, 0, N - 1);  

}

template<typename T>
void Qsort(T A[], int Left, int Right){

    if (Left + CutOff <= Right){  //元素个数大于CutOff=3,则一定可以使用“三数中值分割法”

        int i = Left;
        int j = Right;
        //int center = (i + j) / 2;
        T pivot = A[i];  //以第一个元素为枢纽元

        while (i < j){
            while (i<j && A[j]>pivot){
                j--;
            }
            if (i < j){
                A[i] = A[j];
                //i++;
            }


            while (i < j && A[i] < pivot){
                i++;
            }
            if (i < j){
                A[j] = A[i];
                //j--;
            }

        }
        A[i] = pivot;
        Qsort(A, Left, i - 1);  //递归调用
        Qsort(A, i + 1, Right);

    }
    else{
        InsertionSort(A + Left, Right - Left + 1);  //使用插入排序
    }

}

简单的确定枢纽元方法
//template<typename T>
//T Median3(T *&A, int Left,int Right){
//  int center = (Left + Right) / 2;
//
//  int tmp = A[center];
//  A[center] = A[Right - 1];
//  A[Right-1] = tmp;
//  return A[Right - 1];
//}