排序算法：快速排序

什么是快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设我刚开始有数组int[]{8,3,2,1,7}
选取基准元素为 arr[0] = 8

从右往左开始比较，如果比基准元素arr[0]大，j就左移一位，否则arr[0]=arr[j],经过比较，结果变为

从左往右即开始比较，如果比基准元素arr[0]小，i就左移一位，直到i移动到j，结果变为

i==j，第一次循环结束，arr[i]=arr[0],结果变为

发现基准元素8的左侧都比基准元素小，右侧比基准元素大，就这样迭代下去。

快速排序的时间以及空间复杂度

平均时间复杂度O(n*n)
空间复杂度o(log(n))
是不稳定的排序算法

快速排序的使用

工具类的修改

private static void quickSort(int[] ints, int begin, int end) {
        // 递归退出条件 当begin >= end的时候退出循环
        if(begin >= end){
            return;
        }
        int i = begin, j = end;
        int key = ints[i];
        int temp;
        while (i < j) {
            // 先从右边开始 选出比其小的值 所以是>=
            while (i < j && ints[j] >= key) {
                j--;
            }
            temp = ints[i];
            ints[i] = ints[j];
            ints[j] = temp;
            while (i < j && ints[i] <= key) {
                i++;
            }
            temp = ints[i];
            ints[i] = ints[j];
            ints[j] = temp;
        }
        // 此时 i == j 左边都比ints[i]小，右边都比ints[i]大
        // 向左递归
        quickSort(ints, begin, i - 1);
        // 向右递归
        quickSort(ints, i + 1, end);
}

测试

public static void main(String[] args) {
		int[] arr = new int[] {8,3,2,1,7};
		SortUtil.quickSort(arr, 0, arr.length-1);
		StringBuilder sBuilder = new StringBuilder();
		sBuilder.append("[");
		for (int i : arr) {
			sBuilder.append(i);
			sBuilder.append(",");
		}
		sBuilder.reverse();
		sBuilder.deleteCharAt(0);
		sBuilder.reverse();
		sBuilder.append("]");
		System.out.println(sBuilder);
	}

最坏情况时间复杂度分析

最坏情况下的时间复杂度：
最坏情况即元素基本有序的情况，那么对于下列代码片来说

while(i < j && arr[j] > orgin) j--;
			arr[low] = arr[j];
			while(i < j && arr[i] < orgin) i++;
			arr[j] = arr[i];

我们可以发现，如果元素基本有序，则上述代码片需要执行n次，所以最坏时间复杂度为O(n*n)