快速排序

快速排序的核心操作是 Partition

先从当前待排序区间中，选取一个基准值（可以是第一个元素也可以是最后一个元素，如果想选中间元素，就必须把这个元素交换到最前面或者是最后面）

再对整个区间进行整理，整理成基准值左侧元素都小于基准值，右侧都大于等于基准值，如果是选取最后一个元素为基准值，就让 left 从左往右找比基准值大的元素，让 right 从右往左找比基准值小的元素，（如果是选取第一个元素为基准值，那就先从右往左找，再从左往右找），交换 left 和 right 位置元素，重复这步操作过程，直到 left 和 right 重合，就算完成一趟 partition 操作

再对左右区间的序列进行上述操作，用递归来实现
直至排序完成

代码如下：

 // 快速排序（升序为例）
    public static void quickSort(int[] array) {
        //创建一个辅助方法，来进行递归
        quickSortHelper(array,0,array.length-1);
    }

    private static void quickSortHelper(int[] array, int left, int right) {
        if(left >= right) {
            // 说明区间中只有一个元素或是0个元素，就不需要进行排序
            return;
        }
        // 整理之后，基准值所在位置
        int index = partition(array,left,right);
        // 在[left,index-1]递归寻找基准值
        quickSortHelper(array,left,index-1);
        // 在[index+1，right]递归寻找基准值
        quickSortHelper(array,index+1,right);
    }

    private static int partition(int[] array, int left, int right) {
        int baseValue = array[right];
        int i = left;
        int j = right;
        while(i < j){
            // 1.从左往右找一个比基准值大的值
            while(i < j && array[i] <= baseValue) {
                 i++;
            }
            // 此时 i 指向大于基准值的元素
            // 2.找一个比基准值小的值
            while(i < j && array[j] >= baseValue) {
                j--;
            }
            // 此时 j 指向小于基准值的元素
            // 3.交换 i 和 j 位置元素
            if(i < j) {
                swap(array, i,j);
            }
        }
        // i 和 j 重合
        // 交换 i 位置元素和 基准值
        swap(array, i, right);
        return i;
    }
    
	public static void swap(int[] array, int a, int b) {
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

快速排序的性能指标：

1. 时间复杂度：（和选取基准值位置有关）
   最坏情况下是O（N^2），每次取的基准值正接近最大或是最小值，
   平均情况下是O（NLogN）

2. 空间复杂度：占用的空间取决于递归的深度
   最坏情况下O（N）
   平均情况下是O（logN）

3. 稳定性：不稳定排序

快速排序的优化：

1. 优化基准值的选择，随机挑三个数字，取三个数字中中间值作为基准值
2. 当前待排序数组元素个数比较少时，就不再继续递归了，而是直接进行插入排序
3. 当递归深度达到一定程度的时候，此时待排序区间如果数目较多，就可以使用堆排序