快速排序

快速排序（Java）

声明：此文章参考https://www.cnblogs.com/c4isr/p/4603980.html

一、原理（分治法）

1. 先从数列中取出一个数作为基准数。
2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数

二、时间复杂度

　　时间复杂度为O(nlog2n)~O(n2)，空间复杂度O(log2n)，此排序是不稳定的

三、代码实现

　　这里主要是有三种选取基准元的方法，不同选取基准元的方法有不同的用处，还有一些快速排序的优化算法，具体可以看文章开头的链接

1. 固定基准元（基本的快速排序方法）
2. 随机基准元（在待排序列是部分有序时，固定选取基准元使快排效率底下，要缓解这种情况，就引入了随机选取基准元）
3. 三数取中基准元（虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取基准）

/**
     * 划分数组
     * @param arr 数组
     * @param low 起始位置
     * @param high 结束位置
     */
    public int partition(int arr[],int low,int high) {
        //如果传入的参数不符合，结束
        if (arr == null || low < 0 || high >= arr.length) {
            new Exception("输出不合法！");
        }
        //固定基准元为数组第一位
        int point = arr[low];
        while (low < high) {
            //如果从后往前与基准值比较，发现比基准值大，则下标减一
            while (low < high && arr[high] >= point){
                high--;
            }
            //从后往前遍历完后，将该位置上的值赋给数组第一位（此时数组第一位已被复制到point中，可以认为现在它是空的）
            arr[low] = arr[high];
            //同理，从前往后与基准值比较，比基准值小，则下标加一
            while (low < high && arr[low] <= point){
                low++;
            }
            //同理，arr[high]上的值已经被上一个的arr[low]复制，所以也可以认为现在这个位置是空的，可以进行复制（挖空原理）
            arr[high] = arr[low];
        }
        //最后将基准值赋给最后一个空位置，补全数组
        arr[low] = point;
        return low;
    }

    /**
     * 随机选取基准值
     * 选取之后与数组首位进行交换，等到进行快速排序时，直接选取首位，就相当于随机选择了基准值
     * @param arr
     * @param left
     * @param right
     */
    public void referenceValue(int arr[],int left, int right) {
        //随机选择一个基准，预防待排数据有序，选择的数据是left-right之间
        Random random = new Random();
        int randomPoint = random.nextInt(right - left +1) + left;
        System.out.println("选择的基准数下标为：" + randomPoint + "\n基准数为：" + arr[randomPoint]);
        System.out.println("arr[" + randomPoint + "]与数组arr[" + left + "]进行交换");
        System.out.println("=========================");
        swap(arr,randomPoint,left);
    }

    /**
     * 三数取中基准元，并将确定好的基准元与数组首位交换
     * @param arr
     * @param low
     * @param high
     */
    public void partitionMedianOfThree(int[] arr, int low, int high){
        int mid = low + (high + -low) / 2;
        if (arr[mid] > arr[high])
        {
            swap(arr, mid, high);
        }
        if (arr[low] > arr[high])
        {
            swap(arr, low, high);
        }
        //将中间大小的数与第一个数交换
        if (arr[mid] > arr[low])
        {
            swap(arr, mid, low);
        }
    }

    /**
     * 固定基准元排序
     * @param arr
     * @param left
     * @param right
     */
    public void sort(int[] arr, int left, int right) {
        if (left < right) {
            int boundary = partition(arr,left,right);
            sort(arr, left, boundary - 1);
            sort(arr, boundary + 1, right);
        }
    }

    /**
     * 随机基准元排序
     * @param arr
     * @param left
     * @param right
     */
    public void sortRandom(int[] arr, int left, int right) {
        if (left < right) {
            referenceValue(arr,left,right);
            int boundary = partition(arr,left,right);
            sort(arr, left, boundary - 1);
            sort(arr, boundary + 1, right);
        }
    }

    /**
     * 三数取中基准元快速排序
     * @param arr
     * @param left
     * @param right
     */
    public void sortMedianOfThree(int []arr, int left, int right) {
        if (left < right) {
            partitionMedianOfThree(arr,left,right);
            int boundary = partition(arr,left,right);
            sort(arr, left, boundary - 1);
            sort(arr, boundary + 1, right);
        }
    }

    /**
     * 交换函数
     * @param arr
     * @param left
     * @param right
     */
    public void swap(int arr[],int left,int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }


    @Test
    public void quickSort(){
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*100);
        }
        System.out.println("------原始数据------\n"+
                Arrays.toString(arr));
        // sort(arr,0, arr.length - 1);
        // sortRandom(arr,0,arr.length - 1);
        sortMedianOfThree(arr,0,arr.length - 1);
        System.out.println("------排序结果-------");
        System.out.println(Arrays.toString(arr));
    }