基本思想：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {9,8,7,6,5,4,3,2,1};
        quickSort(arr,0,arr.length-1);
    }

    public static void quickSort(int arr[],int l,int r){
        if (l < r) {
            //调整当前数组并返回分割点位置
            int m = adjust(arr, l, r);
            //递归调整分割点左边数组
            quickSort(arr, l, m-1);
            //递归调整分割点右边数组
            quickSort(arr, m + 1, r);
        }
    }

    //以首位数字为基数，将比基数小数字放在基数左边，比基数大的数放在基数右边
    //注意，此算法是利用在同一个数组上做调整，未另开辟空间
    public static int adjust(int arr[],int l,int r){
        int i = l;
        int j = r;
        int base = arr[i];
        while (i < j){
            //从右往左找比基准点小的数，找到交换位置，找不到往左走一步继续找
            while (i < j && arr[j] >= base){
                j--;
            }
            //交换
            arr[i] = arr[j];
            //从左往右找比基准点大的数，找到交换位置，找不到往右走一步继续找
            while (i < j && arr[i] <= base){
                i++;
            }
            arr[j] = arr[i];
        }
        //i为基准点的目标位置
        arr[i] = base;
        return i;
    }
}

最优时间复杂度：O(n*logn)，最坏时间复杂度O(n2)
最优空间复杂度都为：O(logn)，最坏空间复杂度O(n)。空间复杂度主要是由递归造成的栈空间使用。

由于关键字的比较与交换是跳跃进行的，因此，快速排序是一种不稳定的排序方式。

参考：https://blog.csdn.net/morewindows/article/details/6684558