经典排序算法——快速排序

对于一个int数组，请编写一个快速排序算法，对数组元素排序。

给定一个int数组A及数组的大小n，请返回排序后的数组。

测试样例：

[1,2,3,5,2,3],6

[1,2,2,3,3,5]

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        // write code here
        if(A==NULL || n<2)
            return A;
        process(A,0,n-1);
        return A;
    }
    
    int* process(int* A, int low,int high) {
        if (low < high) {
            int mid = partition(A, low, high);
            process(A, low, mid-1);//对A[low...mid-1]进行递归操作排序
            process(A, mid + 1, high);//对A[mid+1...high]进行递归操作排序
        }
        return A;
    }
    
    int partition(int* A,int low,int high){ //快排算法的划分过程，将数组划分为左右两个子数组
        int pivot = A[low];
        int i = low;
        int j = high;
        if (low < high) 
        {
            while (i < j) 
            {
                while (i < j && pivot <= A[j])  j--;//找到比基准数小的元素
                if (i < j)  A[i] = A[j];
                while (i < j && pivot >= A[i])  i++;//找到比基准数大的元素
                if (i < j)  A[j] = A[i];
            }
            A[i] = pivot;
        }
        return i;
    }
};

快排partition部分实现方法二：

首先随机选定数组中某个元素作为划分值，将划分值交换到数组最末尾，定义变量small表示小于划分值区间的最右边界的下标，初始化小于划分值区间为-1；遍历数组，发现比划分值小的元素，则将其与small右边一位元素交换，扩展小于区间，直到遍历结束，最后将划分值与small后一位元素交换。

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        // write code here
        if(A==NULL || n<2)
            return A;
        process(A,0,n-1);
        return A;
    }
    
    int* process(int* A, int low,int high) {
        if (low < high) {
            int mid = partition(A, low, high);
            process(A, low, mid-1);//对A[low...mid-1]进行递归操作排序
            process(A, mid + 1, high);//对A[mid+1...high]进行递归操作排序
        }
        return A;
    }
    
    int partition(int* A,int low,int high){ //快排算法的划分过程，将数组划分为左右两个子数组
        int pivot = low+(high-low)/2;//将中间数作为划分值
        int small = low-1;//其中small为小于划分值区间右边界下标
        swap(A,pivot,high);//将划分值交换到数组末尾
        for(int i=low;i<high;++i)//遍历数组
        {
           if(A[i]<A[high])//发现比划分值小的元素，则与small右边一位元素交换，扩展小于区间
           {
               ++small;
               if(small!=i)  swap(A,i,small);
           }
        }
        ++small;
        swap(A,small,high);//将划分值重新回归原位
        return small;
    }
    
    void swap(int* A,int i,int j){
        int temp=A[i];
        A[i]=A[j];
        A[j]=temp;
    }
};