深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐

目录

1. 算法介绍⭐⭐⭐⭐⭐

1.1 图示解析

2. 执行流程和代码实现

2.1 挖坑法⭐⭐⭐⭐

2.2 Hoare法⭐⭐⭐⭐

2.3 前后指针法(了解即可)

2.4  非递归实现快速排序(了解即可)

4. 性能分析

5. 算法改进

5.1 三数选中法

5.2 最后几行数据采用直接插入排序


1. 算法介绍⭐⭐⭐⭐⭐

快速排序也是“交换”类的排序,运用了分治的思想,它通过多次划分操作实现排序。以升序为例,其执行流程可以概括为:每一趟选择当前所有子序列中的一个关键字(通常是第一个)作为基准值,将子序列中比基准值小的移动到基准值的前边,比基准值大的移到基准值后边;当本趟所有子序列都被基准值以上述规则划分完毕后,会得到新的一组更短的子序列,它们成为下一趟划分的初始序列集。

(1)从待排序区间选择一个数,作为基准值(mid);

(2)Partition: 遍历整个待排序区间,将比基准值小的(可以包含相等的)放到基准值的左边,将比基准值大的(可以包含相等的)放到基准值的右边;

(3)采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 == 1,代表已经有序,或者小区间的长度 == 0,代表没有数据。

1.1 图示解析

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第1张图片

2. 执行流程和代码实现

2.1 挖坑法⭐⭐⭐⭐

小伙伴们,自行放大图片看一下,很细滴!!!

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第2张图片

    /*
    下面性能部分细讲
    时间复杂度:
        最好情况是:O(NlogN) 均匀分割待排序列,尽量满二叉树
        最坏情况是:O(N^2),有序或者逆序,单分支的树
    空间复杂度:
        最好情况是:O(logN) 树的高度,把持着mid变量
        最坏情况是:O(N),有序或者逆序,单分支的树
    稳定性:不稳定
     */
    //这里为了统一其他排序算法的接口,所以只传一个参数——数组
    public static void quickSort(int[] array) {

        quick(array, 0, array.length - 1);
    }

    //划分
    private static void quick(int[] array, int start, int end) {
        //这里为什么是>=,因为防止end到了start后面,导致越届
/*
        s e
        mid
    例如:1 2
        再递归进去,end == -1,start == 0,所以必须交 =
 */
        if (start >= end) {
            return;
        }

        int mid = partition1(array, start, end);
        //递归左边
        quick(array, start, mid - 1);
        //递归右边
        quick(array, mid + 1, end);
    }

    //第一种:快速排序,挖坑法,无优化版本
    //每一趟的操作,交换,填坑
    private static int partition1(int[] array, int left, int right) {
        int tmp = array[left];//保存最左位置的值
        //开始找坑
        //多次左右走
        while (left < right) {
            //先右往左走,找一个值比tmp小的,一次循环或者说一次向右走
            // 这里必须要是 >= ,不然当下标0和下标array.length的话,就会陷入死循环,这两个下标的值一直在交换
            //提问:为什么不需要再次++,去进入循环呢?
            while (left < right && array[right] >= tmp)
                right--;
            array[left] = array[right];
            //从左往右走,找一个值比tmp大的,一次循环或者说一次向左走
            while (left < right && array[left] <= tmp)
                left++;
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    public static void main(String[] args) {
        int[] a = {10,10,9,8,7,6,5,4,3,2,1};
        Sort.quickSort2(a);
        for (int x : a) {
            System.out.print(x + " ");
        }
    }

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第3张图片

2.2 Hoare法⭐⭐⭐⭐

思路:设置两个下标指针i和j,j向左走,找到比基准值(pivot)小的值先停下来,不交换,i向右走,找到比基准值(pivot)大的值先停下来,然后交换array[i] 和 array[j],当i和j相遇后,交换array[i] 和 array[left]。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第4张图片

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第5张图片

    /*
    下面性能部分细讲
    时间复杂度:
        最好情况是:O(NlogN) 均匀分割待排序列,尽量满二叉树
        最坏情况是:O(N^2),有序或者逆序,单分支的树
    空间复杂度:
        最好情况是:O(logN) 树的高度,把持着mid变量
        最坏情况是:O(N),有序或者逆序,单分支的树
    稳定性:不稳定
     */
    //这里为了统一其他排序算法的接口,所以只传一个参数——数组
    public static void quickSort(int[] array) {

        quick(array, 0, array.length - 1);
    }

    //划分
    private static void quick(int[] array, int start, int end) {
        //这里为什么是>=,因为防止end到了start后面,导致越届
/*
        s e
        mid
    例如:1 2
        再递归进去,end == -1,start == 0,所以必须交 =
 */
        if (start >= end) {
            return;
        }

        int mid = partition2(array, start, end);
        //递归左边
        quick(array, start, mid - 1);
        //递归右边
        quick(array, mid + 1, end);
    }

    //第二种快速排序,Hoare法,主要是交换的方式不同
    private static int partition2(int[] array, int left, int right) {
        int tmp = array[left];
        int i = left;//把left开始的下标保存起来先
        while (left < right) {
/*
为什么不能先走左呢?
答:因为先走左的话,最后right会停在比mid大的值的下标,left找到right停下来,交换i和left的值,导致不满足快排的结果
 */
            //这两个循环,永远是right追left
            while (left < right && array[right] >= tmp)
                right--;
            while (left < right && array[left] <= tmp)
                left++;
            swap(array, left, right);//自定义的交换方法
        }
        swap(array, i, left);
        return left;
    }

    public static void main(String[] args) {
        int[] a = {10,10,9,8,7,6,5,4,3,2,1};
        Sort.quickSort2(a);
        for (int x : a) {
            System.out.print(x + " ");
        }
    }


深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第6张图片

2.3 前后指针法(了解即可)

总体思路:prev一直往后走(prev++),当array[prev]小于array[left]的时候,cur++。当array[cur] != array[prev]时。

具体看如下的过程:

    //第三种排序算法:前后指针法
    //写法一
    private static int partition3(int[] array, int left, int right) {
        int cur = left;//prev记录的是最后一位比array[left]的下标
        int prev = left + 1;
        while (cur <= right) {
            if (array[prev] < array[left] && array[++cur] != array[prev]) {
                swap(array, prev, cur);
            }
            prev++;
        }
        swap(array, left, cur);
        return cur;
    }

第一步:先把第一个元素定为基准值。

cur 记录第一个元素6的下标,prev记录第二个元素的1的下标。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第7张图片

第二步:因为第一步的1 < 6,cur++且没发生交换,prev++(注意:prev无论如何都会一直往前走) 。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第8张图片

第三步:因为第二步的2 < 6,cur++且没发生交换,prev++(注意:prev无论如何都会一直往前走) 。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第9张图片

第四步:因为第三步的7 > 6,所以 cur不往前走,prev++,来到元素9的下标。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第10张图片

第五步:因为第四步的9 > 6,所以 cur不往前走,prev++,来到元素3的下标。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第11张图片

第六步:因为第五步的3 < 6,所以cur++来到元素7的下标,接着交换array[cur]和array[prev]的元素,后prev++(代码有体现)。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第12张图片

第七步:因为第五步的4 < 6,所以cur++来到元素的下标,接着交换array[cur]和array[prev]的元素,后prev++(代码有体现)。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第13张图片

第八步:因为第七步的5 < 6,所以cur++来到元素的下标,接着交换array[cur]和array[prev]的元素,后prev++(代码有体现)。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第14张图片

第九步:因为第八步的10 > 6,所以 cur不往前走,prev++,来到元素8的下标。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第15张图片

然后排序元素6左边子序列和右边子序列,一直重复,直至排序完成!

总结:我们可以发现cur永远都是记录着小于基准值的最后一个元素的下标,不断地把比基准值大的元素往右推! 

        /*
    下面性能部分细讲
    时间复杂度:
        最好情况是:O(NlogN) 均匀分割待排序列,尽量满二叉树
        最坏情况是:O(N^2),有序或者逆序,单分支的树
    空间复杂度:
        最好情况是:O(logN) 树的高度,把持着mid变量
        最坏情况是:O(N),有序或者逆序,单分支的树
    稳定性:不稳定
     */
    //这里为了统一其他排序算法的接口,所以只传一个参数——数组
    public static void quickSort(int[] array) {

        quick(array, 0, array.length - 1);
    }

    //划分
    private static void quick(int[] array, int start, int end) {
        //这里为什么是>=,因为防止end到了start后面,导致越届
/*
        s e
        mid
    例如:1 2
        再递归进去,end == -1,start == 0,所以必须交 =
 */
        if (start >= end) {
            return;
        }

        int mid = partition3(array, start, end);
        //递归左边
        quick(array, start, mid - 1);
        //递归右边
        quick(array, mid + 1, end);
    }

    //第三种排序算法:前后指针法
    //写法一
    private static int partition3(int[] array, int left, int right) {
        int cur = left;//prev记录的是最后一位比array[left]的下标
        int prev = left + 1;
        while (cur <= right) {
            if (array[prev] < array[left] && array[++cur] != array[prev]) {
                swap(array, prev, cur);
            }
            prev++;
        }
        swap(array, left, cur);
        return cur;
    }

    public static void main(String[] args) {
        int[] a = {6,1,2,7,9,3,4,5,10,8};
        Sort.quickSort2(a);
        for (int x : a) {
            System.out.print(x + " ");
        }
    }

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第16张图片

2.4  非递归实现快速排序(了解即可)

使用栈完成效果

(1)先准备一个栈,先调用一次partition1()方法,把6放到最终位置。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第17张图片

 (2)将左边子序列的start和end下标进栈,右子序列的start和end下标进栈。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第18张图片

(3)然后出栈,先赋值个right,再给left,循环进行,就能完成排序。

注意:会将右子序列排序完成,再去排序左子序列,小伙伴们可以根据我们上面的部分流程,把整个算法流程画出来!

  
    //第一种:快速排序,挖坑法,无优化版本
    //每一趟的操作,交换,填坑
    private static int partition1(int[] array, int left, int right) {
        int tmp = array[left];//保存最左位置的值
        //开始找坑
        //多次左右走
        while (left < right) {
            //先右往左走,找一个值比tmp小的,一次循环或者说一次向右走
            // 这里必须要是 >= ,不然当下标0和下标array.length的话,就会陷入死循环,这两个下标的值一直在交换
            //提问:为什么不需要再次++,去进入循环呢?
            while (left < right && array[right] >= tmp)
                right--;
            array[left] = array[right];
            //从左往右走,找一个值比tmp大的,一次循环或者说一次向左走
            while (left < right && array[left] <= tmp)
                left++;
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    //非递归实现快速排序
    //用栈实现
    public static void quickSort2(int[] array){
        Deque stack = new LinkedList<>();
        int left = 0;
        int right = array.length - 1;
        int mid = partition1(array,left,right);
        if(mid > left + 1){
            stack.push(left);
            stack.push(mid - 1);
        }
        if(mid < right - 1){
            stack.push(mid + 1);
            stack.push(right);
        }
        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            mid = partition1(array,left,right);
            if(mid > left + 1){
                stack.push(left);
                stack.push(mid - 1);
            }
            if(mid < right - 1) {
                stack.push(mid + 1);
                stack.push(right);
            }
        }
    }

4. 性能分析

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第19张图片

(1)最好的情况:快速排序最理想的情况就是满二叉树, 此时时间复杂度是:O(nlogn);空间复杂度是:O(logn)。

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第20张图片

(2)最坏的情况:原数据有序或者逆序,这样快速排序就成了单分支树了,此时时间复杂度是:O(n^2),空间复杂度是:O(n)。

5. 算法改进

5.1 三数选中法

取待排序数组中 头、中、尾三个位置的元素、取中间值作为基准元素。(此种方式最好,递归调用栈的深度最低)1.取待排序数组中 头、中、尾三个位置的元素、取中间值作为基准元素。(此种方式最好,递归调用栈的深度最低)。

    //优化的方案,均匀的分割!三数取中法
    private static int midThree(int[] array, int left, int right) {
        int mid = (left + right) / 2;
        if(array[left] > array[right]){
            if(array[mid] < array[right]){
                return right;
            }else if(array[mid] > array[left]){
                return left;
            }else {
                return mid;
            }
        }else{
            //array[right] > array[left]
            if(array[mid] < array[left]){
                return left;
            }else if(array[mid] > array[right]){
                return right;
            }else{
                return mid;
            }
        }
    }

改进后的代码是:

    /*
    时间复杂度:
        最好情况是:O(NlogN) 均匀分割待排序列,尽量满二叉树
        最坏情况是:O(N^2),有序或者逆序,单分支的树
    空间复杂度:
        最好情况是:O(logN) 树的高度,把持着mid变量
        最坏情况是:O(N),有序或者逆序,单分支的树
    稳定性:不稳定
     */
    //这里为了统一其他排序算法的接口,所以只传一个参数——数组
    public static void quickSort(int[] array) {

        quick(array, 0, array.length - 1);
    }

    //划分
    private static void quick(int[] array, int start, int end) {
        //这里为什么是>=,因为防止end到了start后面,导致越届
/*
        s e
        mid
    例如:1 2
        再递归进去,end == -1,start == 0,所以必须交 =
 */
        if (start >= end) {
            return;
        }

        //优化一:
        //排序,返回到最终位置的元素下标
        int index = midThree(array,start,end);
        swap(array,start,index);
        int mid = partition3(array, start, end);
        //递归左边
        quick(array, start, mid - 1);
        //递归右边
        quick(array, mid + 1, end);
    }

    //第一种:快速排序,挖坑法,无优化版本
    //每一趟的操作,交换,填坑
    private static int partition1(int[] array, int left, int right) {
        int tmp = array[left];//保存最左位置的值
        //开始找坑
        //多次左右走
        while (left < right) {
            //先右往左走,找一个值比tmp小的,一次循环或者说一次向右走
            // 这里必须要是 >= ,不然当下标0和下标array.length的话,就会陷入死循环,这两个下标的值一直在交换
            //提问:为什么不需要再次++,去进入循环呢?
            while (left < right && array[right] >= tmp)
                right--;
            array[left] = array[right];
            //从左往右走,找一个值比tmp大的,一次循环或者说一次向左走
            while (left < right && array[left] <= tmp)
                left++;
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    //优化的方案,均匀的分割!三数取中法
    private static int midThree(int[] array, int left, int right) {
        int mid = (left + right) / 2;
        if(array[left] > array[right]){
            if(array[mid] < array[right]){
                return right;
            }else if(array[mid] > array[left]){
                return left;
            }else {
                return mid;
            }
        }else{
            //array[right] > array[left]
            if(array[mid] < array[left]){
                return left;
            }else if(array[mid] > array[right]){
                return right;
            }else{
                return mid;
            }
        }
    }

5.2 最后几行数据采用直接插入排序

直接插入排序:数据越有序,效率越高!

深入浅出排序算法之快速排序(重要)⭐⭐⭐⭐⭐_第21张图片

    /*
    时间复杂度:
        最好情况是:O(NlogN) 均匀分割待排序列,尽量满二叉树
        最坏情况是:O(N^2),有序或者逆序,单分支的树
    空间复杂度:
        最好情况是:O(logN) 树的高度,把持着mid变量
        最坏情况是:O(N),有序或者逆序,单分支的树
    稳定性:不稳定
     */
    //这里为了统一其他排序算法的接口,所以只传一个参数——数组
    public static void quickSort(int[] array) {

        quick(array, 0, array.length - 1);
    }

    //划分
    private static void quick(int[] array, int start, int end) {
        //这里为什么是>=,因为防止end到了start后面,导致越届
/*
        s e
        mid
    例如:1 2
        再递归进去,end == -1,start == 0,所以必须交 =
 */
        if (start >= end) {
            return;
        }

        //优化二:
        if(end - start + 1 <= 14){
            insertSort2(array,start,end);
        }
        //优化一:
        //排序,返回到最终位置的元素下标
        int index = midThree(array,start,end);
        swap(array,start,index);
        int mid = partition3(array, start, end);
        //递归左边
        quick(array, start, mid - 1);
        //递归右边
        quick(array, mid + 1, end);
    }

    //第一种:快速排序,挖坑法,无优化版本
    //每一趟的操作,交换,填坑
    private static int partition1(int[] array, int left, int right) {
        int tmp = array[left];//保存最左位置的值
        //开始找坑
        //多次左右走
        while (left < right) {
            //先右往左走,找一个值比tmp小的,一次循环或者说一次向右走
            // 这里必须要是 >= ,不然当下标0和下标array.length的话,就会陷入死循环,这两个下标的值一直在交换
            //提问:为什么不需要再次++,去进入循环呢?
            while (left < right && array[right] >= tmp)
                right--;
            array[left] = array[right];
            //从左往右走,找一个值比tmp大的,一次循环或者说一次向左走
            while (left < right && array[left] <= tmp)
                left++;
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    //直接插入排序
    public static void insertSort2(int[] arr,int left,int right) {
        //代码可以从i = 1开始算起,但是做题画图时,一定要从i = 0开始算起
        for (int i = left + 1; i < arr.length; i++) {
            int j = i - 1;
            int tmp = arr[i];
            for (; j >= left; j--) {
                //如果arr[j] > tmp变成arr[j] >= tmp就变成不稳定了
                if (arr[j] > tmp) {
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j + 1] = tmp;
        }
    }

你可能感兴趣的:(Java数据结构,Java版本的算法题,排序算法,java,算法)