第7章：快速排序

随机化快速排序：

1：对数组的随机划分：

int random(int i,int j)
{
        return rand()%(j-i+1)+i;
}

template<class Type>
int partition(vector<Type>& array, int left,int right)
{
        Type compareVal=array[right];

        int i=left-1;
        for(int j=left;j!=right;++j)
                if(array[j]<=compareVal){
                        ++i;
                        swap(array[i],array[j]);
                }
        swap(array[i+1],array[right]);

        return i+1;
}

template<class Type>
int randomPartition(vector<Type>& array,int left,int right)
{
        int pivotPosition=random(left,right);
        swap(array[pivotPosition],array[right]);
        return partition(array,left,right);
}

2：快速排序：

template<class Type>
void quickSort(vector<Type>& array,int left,int right)
{
        if(left<right){
                if(20<right-left){
                        int breakPoint=randomPartition(array,left,right);
                        quickSort(array,left,breakPoint-1);
                        quickSort(array,breakPoint+1,right);
                }
                else
                        insertionSort(array,left,right);
        }
}

template<class Type>
void quickSort(vector<Type>& array)
{
        if(array.size()==0)
                throw underflow_error("the array is empty.Please enter again");

        if(array.size()==1)
                return;

        quickSort(array,0,array.size()-1);
}