排序算法java实现——快速排序

一、基本思路

基本思路是： 快速排序是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分小，然后再按此方法对这两部分数据分别进行快速排序，整个过程可以递归进行。

简单来说： 就是将待排序列不断的拆分成两部分，其中前半部分的所有数据都比后半部分小。

举例：
有一序列为：-9, 78, 0, 23, -567, 70要求按升序排列
以中轴上下标为mid = (left + right) / 2的数t为基数，将比t小的都放到t左边，将比t大的都放到t右边。并不断递归。

1. 第一趟（mid = (0+5)/2=2，t = arr[2]=0)
   (1)-9，-567，0，23，78，70（交换78和-567）
   得到新的序列：-9，-567，0，23，78，70
   2.第二趟（将新的序列进行左右递归，将0左右各看为一部分）
   （1）0左：-567，-9（mid = (0+1) / 2 = 0,t = arr[0] = -9，-9和-567交换）
   （2）0右：23，70，78（mid = (3+2) / 2 = 4,t = arr[4] = 78，70和78交换）
   得到新的序列：-567，-9，0，23，70，78
   3.第三趟（将0右边新的序列进行左右递归，将78左右各看为一部分）
   （1）78左：23，70，78（mid = (3+4) / 2 = 3,t = arr[3] = 23，无需交换，此时无法再划分，将退出递归）
   得到新的序列：-567，-9，0，23，70，78

图解：

二、算法分析

时间： 快速排序的一次划分算法从两头交替搜索，直到low和high重合，因此其时间复杂度是O(n)；而整个快速排序算法的时间复杂度与划分的趟数有关。
  理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过$lo{g}_{2}n$趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(n$lo{g}_{2}n$)。
  最坏的情况是，每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表中一个为空表，另一子表的长度为原表的长度-1。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n²)。
空间： 尽管快速排序只需要一个元素的辅助空间，但快速排序需要一个栈空间来实现递归。最好的情况下，即快速排序的每一趟排序都将元素序列均匀地分割成长度相近的两个子表，所需栈的最大深度为log2(n+1)；但最坏的情况下，栈的最大深度为n。这样，快速排序的空间复杂度为O($lo{g}_{2}n$)。

算法	平均时间	最好情形	最差情形	稳定度	空间复杂度	备注
快速排序	O(n$lo{g}_{2}n$)	O(n$lo{g}_{2}n$)	O(n²）	不稳定	O(n$lo{g}_{2}n$)	n大时较好

三、代码实现

import java.util.Arrays;

/**
 * @author dankejun
 * @create 2020-04-29 15:15
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, -567, 70};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left;//左下标
        int r = right;//右下标
        int mid = arr[(left + right) / 2];//中轴
        int temp ;//用于交换的临时变量

        while (l < r) {
            while (arr[l] < mid) {//l游标右移，直到找到中轴左边比mid大的元素
               l += 1;
            }
            while (arr[r] > mid) {//r游标左移，直到找到中轴左边比mid小的元素
                r -= 1;
            }
            if (l >= r) {//已经遍历完所以元素
                break;
            }

            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //左边到达中轴
            if (arr[l] == mid) {
                r -= 1;
            }
            //右边到达中轴
            if (arr[r] == mid) {
                l += 1;
            }
        }
        //当l和r都到达中轴，利用l++,r--来使l>r从而退出
        if (l == r) {
            l += 1;
            r -= 1;
        }

        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }

    }
}

测试结果：