排序之快速排序

快速排序的在内排中起到比较重要的作用，平均时间复杂度达到O(nlogn)。

升序快速排序

int partition(vector<int> &vi,int start,int end){
    int key=vi[start];
    while(start<end){
        while(start<end&&vi[end]>=key)
            end--;
        vi[start]=vi[end];
        while(start<end&&vi[start]<key)
            start++;
        vi[end]=vi[start];
    }
    vi[start]=key;
    return start;
}
void quickCore(vector<int> &vi,int start,int end){
    if(start<end){
        int idx =partition(vi,start,end);
        quickCore(vi,start,idx-1);
        quickCore(vi,idx+1,end);
    }
}

void quickSort(vector<int>&vi){
    quickCore(vi,0,vi.size()-1);  
}

指定排序顺序快速排序

bool cmp(const int &a,const int &b){
    return (b-a>=0)?true:false;
}
bool rcmp(const int &a,const int &b){
    return (b-a>=0)?false:true;
}
int partition(vector<int> &vi,int start,int end,bool (*cmp)(const int&,const int&)){
    int key=vi[start];
    while(start<end){
        while(start<end&&cmp(key,vi[end]))
            end--;
        vi[start]=vi[end];
        while(start<end&&!cmp(key,vi[start]))
            start++;
        vi[end]=vi[start];
    }
    vi[start]=key;
    return start;
}
void quickCore(vector<int> &vi,int start,int end,bool (*cmp)(const int&,const int&)){
    if(start<end){
        int idx =partition(vi,start,end,cmp);
        quickCore(vi,start,idx-1,cmp);
        quickCore(vi,idx+1,end,cmp);
    }
}

void quickSort(vector<int>&vi,bool (*cmp)(const int&,const int&)){
    quickCore(vi,0,vi.size()-1,cmp);  
}

指定任意对象和排序规则的快速排序

struct component{
    int a;
    int b;
};
bool cmp(const component& obj1,const component& obj2){
    if(obj2.a>obj1.a)
        return true;
    else if(obj2.a<obj1.a)
        return false;
    else if(obj2.b>=obj1.b)
        return true;
    return false;
}
bool rcmp(const component& obj1,const component& obj2){
    if(obj1.a>obj2.a)
        return true;
    else if(obj1.a<obj2.a)
        return false;
    else if(obj1.b>=obj2.b)
        return true;
    return false;
}

template<class T>
int partition(vector<T> &vi,size_t start,size_t end,bool (*cmp)(const T&,const T&)){
    T key=vi[start];
    while(start<end){
        while(start<end&&cmp(key,vi[end]))
            end--;
        vi[start]=vi[end];
        while(start<end&&!cmp(key,vi[start]))
            start++;
        vi[end]=vi[start];
    }
    vi[start]=key;
    return start;
}
template<class T>
void quickCore(vector<T> &vi,size_t start,size_t end,bool (*cmp)(const T&,const T&)){
    if(start<end){
        size_t idx =partition(vi,start,end,cmp);
        quickCore(vi,start,idx-1,cmp);
        quickCore(vi,idx+1,end,cmp);
    }
}
template<class T>
void quickSort(vector<T>&vi,bool (*cmp)(const T&,const T&)){
    quickCore(vi,0,vi.size()-1,cmp);  
}

迭代器类型快速排序

struct component{
    int a;
    int b;
};
bool cmp(const component& obj1,const component& obj2){
    if(obj2.a>obj1.a)
        return true;
    else if(obj2.a<obj1.a)
        return false;
    else if(obj2.b>=obj1.b)
        return true;
    return false;
}
bool rcmp(const component& obj1,const component& obj2){
    if(obj1.a>obj2.a)
        return true;
    else if(obj1.a<obj2.a)
        return false;
    else if(obj1.b>=obj2.b)
        return true;
    return false;
}
bool cmp1(const int &a,const int &b){
    return (b-a>=0)?true:false;
}
bool rcmp1(const int &a,const int &b){
    return (b-a>=0)?false:true;
}
template<class Iterator, class Comparator>
Iterator partition(Iterator start,Iterator end,Comparator cmp){
    typedef typename iterator_traits<Iterator>::value_type value_type;
    value_type key=*start;
    while(start!=end-1){
        while(start!=end-1&&cmp(key,*(end-1)))
            end--;
        *start=*(end-1);
        while(start!=end-1&&!cmp(key,*start))
            start++;
        *(end-1)=*start;
    }
    *(end-1)=key;
    return end-1;
}
template<class Iterator, class Comparator>
void quickCore(Iterator start,Iterator end,Comparator cmp){
    if(start !=end){
        Iterator idx =::partition(start,end,cmp);
        quickCore(start,idx,cmp);
        quickCore(idx+1,end,cmp);
    }
}
template<class Iterator, class Comparator>
void quickSort(Iterator start,Iterator end,Comparator cmp){
    quickCore(start,end,cmp);  
}
template<class Iterator>
void quickSort(Iterator start,Iterator end){
    quickCore(start,end,less<typename iterator_traits<Iterator>::value_type>());  
}

测试

#include <iostream>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;

int main( )
{ 
    vector<int> vi{1,7,3,1};
    quickSort(vi.begin(),vi.end());
    sort(vi.begin(),vi.end(),cmp1);
    for(int i=0;i<vi.size();i++)
        cout<<vi[i]<<"  ";
    cout<<endl;
    
    vector<component> obj{
      {1,4},
      {3,6},
      {2,8},
      {2,7},
      {1,1}
    };
    quickSort(obj.begin(),obj.end(),cmp);
    for(int i=0;i<obj.size();i++){
        cout<<obj[i].a<<"  "<<obj[i].b<<endl;
    }
    return 0;
}