1.如果待排数组array的大小是0或1则结束递归返回这个数组。

2.从数组中选择一项作为基准项,把剩下的元素分成2个不相关的组。比该数据小的数据排列在左边，比该数据大的数据排列在右边。
SmallThanPivot = {所有<pivot的元素} LargerThanPivot = {所有>pivot的元素}
3.返回重排后的列表，重复前面的过程分别对左边和右边的序列进行快速排序。
QuickSort(SmallThanPivot);Pivot;QuickSort(LargerThanPivot);
 
75,70,65,84,98,78,100,93,55,61,81,68  
//选取75为基准元素,从75的左端往右找到第一个大于75的元素是84,从最右往左第一个小于75的元素是68
75,70,65,68,98,78,100,93,55,61,81,84  
//交换这两个元素,继续从右往左找大于75的元素98,从左往右找小于75的元素61
75,70,65,68,61,55,100,93,78,98,81,84  
//交换55与78。此时左边的指针停留在100处，右边的指针停留在55处，两指针已碰头，这意味着查找结束，现在交换左边的55和75
55,70,65,68,61,75,100,93,78,98,81,84  
//现在75左边的元素都小于75,右边的元素都大于75,这样基准75的位置就确定了
接着把数列划分成两个子列
SmallThanPivot = {55,70,65,68,61}
LagerThanPivot = {100,93,78,98,81,84}
 
void quick_sort(int array[],int first,int last)
{
    if (first >= last) {
        return;
    }
    int left = first + 1; //选取第一作为基准，为从左到右的下标
    int right = last;      //right为从右到左的下标
    while (true) {
        while (array[left] < array[first] && left <= right){
            left++; //找到左边的第一个比基准大的元素
        }
        while (array[right]> array[first] && right >= left){
            right--; //找到右边第一个比基准小的元素
        }
    
        if (left < right) {
            swap(array[left],array[right]);
        } else {
            break;
        }
    
    }
    swap(array[first],array[right]);
    int mid = right;
    quick_sort(array,first,mid-1);
    quick_sort(array,mid+1,last);
}
void testQuickSort()
{
    int array[12] = {75,70,65,84,98,78,100,93,55,61,81,68};
    printArray(array,12);
    quick_sort(array,0,11);
    printArray(array,12);　
//随机生成1000个数排序

　　　　const int n = 1000;
　　　　int array[n] = {0};
　　　　srand(time(NULL));
　　　　for (int i = 0; i < n; ++i) {
　　　　　　array[i] = rand();
　　　　}

　　　　printArray(array,n);

　　　　quick_sort(array,0,n-1);

　　　　printArray(array,n);

}

 改进方法:

1.减少递归栈的容量

利用栈实现快速排序：

 

2.基准的选择

3.短子列表