快速排序（Java）

1、原理

（1）从待排序区间选择一个数，作为基准值；
（2） Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边，不断递归，直至数据完全有序

2、实现

（1）手动实现

（2）代码

import java.util.Arrays;

public class Quick {
    public static void quickSort(int[] array){
        //辅助完成递归操作
        quickHelper(array,0,array.length-1);
    }

    private static void quickHelper(int[] array, int left, int right) {
        if(left >= right){
            //此时数组为空，或者只有一个元素不用排序
            return;
        }
        int index = partition(array,left,right);
        quickHelper(array,left,index-1);
        quickHelper(array,index+1,right);
    }

    private static int partition(int[] array, int left, int right) {
        int start = left;
        int end = right;
        //取最左侧元素为基准值
        int base = array[left];
        while(start < end){
            while(start < end && array[end] >= base){
                end--;
            }// 循环结束时，end指向小于base的值或者与start重合
            while(start<end  && array[start]<=base){
                start++;
            } // 循环结束时，start指向大于base的值或者与end重合
            swap(array,start,end);
        }
        swap(array,left,start);
        return start;
    }
    
    private static void swap(int[] array, int start, int end) {
        int tmp = array[start];
        array[start] = array[end];
        array[end] = tmp;
    }
}

（3）运行结果

3、性能指标

（1）时间复杂度：

最好：O(n*log(n))
平均：O(n*log(n))
最坏：O(n^2)

（2）空间复杂度：

最好：O(log(n))
平均：O(log(n))
最坏：O(n)

（3）稳定性：不稳定