快速排序的一种优化算法（三向切分）

快速排序：

时间复杂度O(N*logN)，最坏情况为O(N^2)

空间复杂度O(1)

但是堆栈深度一般情况为O(logN)，最坏情况为O(N)

---

 

快速排序实现：

partition划分算法：

int Partition(SeqList R，int i，int j)
{
    //调用Partition(R，low，high)时，对R[low..high]做划分，
    //并返回基准记录的位置
    ReceType pivot=R[i]； //用区间的第1个记录作为基准 '
    while(i<j){ //从区间两端交替向中间扫描，直至i=j为止
        while(i<j&&R[j].key>=pivot.key) //pivot相当于在位置i上
            j--； //从右向左扫描，查找第1个关键字小于pivot.key的记录R[j]
        if(i<j) //表示找到的R[j]的关键字<pivot.key
            R[i++]=R[j]； //相当于交换R[i]和R[j]，交换后i指针加1
        while(i<j&&R[i].key<=pivot.key) //pivot相当于在位置j上
            i++； //从左向右扫描，查找第1个关键字大于pivot.key的记录R[i]
        if(i<j) //表示找到了R[i]，使R[i].key>pivot.key
            R[j--]=R[i]; //相当于交换R[i]和R[j]，交换后j指针减1
    } //endwhile
    R[i]=pivot； //基准记录已被最后定位
    return i；
} //partition 

然后，对整个数组进行递归排序：

QUICKSORT(A, p, r)
    if p < r
        then q ← PARTITION(A, p, r)   //关键
    QUICKSORT(A, p, q - 1)
    QUICKSORT(A, q + 1, r)

---

算法导论中提到的快速排序的优化版本：就地重排

PARTITION(A, p, r)
    x ← A[r]         //以最后一个元素，A[r]为主元
    i ← p - 1
    for j ← p to r - 1    //注，j从p指向的是r-1，不是r。
        do if A[j] ≤ x
            then i ← i + 1
            exchange A[i] <-> A[j]
    exchange A[i + 1] <-> A[r]
    return i + 1

---

本文重点：三向切分

快速排序什么时候不适用？元素重复率特别高的时候。

如何优化？三向切分。前后各俩指针，总共四个指针。俩额外的指针指向跟待选元素相同的元素，最后全部置换到中间。

三向切分的好处？重复率高的时候，避免相同元素来回交换，节省交换次数。对于包含大量重复元素的数组，这个算法将排序时间从线性对数级降到了线性级别。

代码：

#include <iostream>  
using namespace std;  
template <typename T>  
void sawp(T a[],int first,int second){  
    T temp;  
    temp = a[first];  
    a[first] = a[second];  
    a[second] = temp;  
}  
template <typename T>  
int sort(T a[],int low,int high){  
    if(low < high){  
        int lt = low,i=low+1,gt = high;  
        int temp = a[low];  
        while(i <= gt){  
            if(a[i] < temp){  
                sawp(a,lt++,i++);  
            }else if(a[i] > temp){  
                sawp(a,i,gt--);  
            }else{  
                i++;  
            }  
        }  
        sort(a,low,lt-1);  
        sort(a,gt+1,high);  
    }   
}  
int main() {  
    int a[] = {2,2,2,2,2,0,0,0,0,0,0,1,5};  
    //int a[] = {2,0,1,5};  
    int len = sizeof(a)/sizeof(int);  
    sort(a,0,len-1);  
    for (int i = 0; i < len; ++i)  
        cout << a[i] << " ";  
    cout << endl;  
}