数据结构与算法(Java篇)笔记--快速排序

简介: 数据结构与算法(Java篇)笔记--快速排序



前言

在我们的程序中,排序是非常常见的一种需求,提供一些数据元素,把这些数据元素按照一定的规则进行排序。比如查询一些订单,按照订单的日期进行排序;再比如查询一些商品,按照商品的价格进行排序等等。所以,接下来我们要学习一些常见的排序算法。


一、选择排序

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

需求:

排序前:{6, 1, 2, 7, 9, 3, 4, 5, 8}

排序后:{1, 2, 3, 4, 5, 6, 7, 8, 9}

二、排序原理

  Step1.首先设定一个分界值,通过该分界值将数组分成左右两部分;

  Step2.将大于或等于分界值的数据放到到数组右边,小于分界值的数据放到数组的左边。此时左边部分 中各元素都小于 或等于分界值,而右边部分中各元素都大于或等于分界值;

  Step3.然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两 部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。

  Step4.重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当 左侧和右侧两个部分的数据排完序后,整个数组的排序也就完成了。

切分原理

把一个数组切分成两个子数组的基本思想:

  Step1.找一个基准值,用两个指针分别指向数组的头部和尾部;

  Step2.先从尾部向头部开始搜索一个比基准值小的元素,搜索到即停止,并记录指针的位置;

  Step3.再从头部向尾部开始搜索一个比基准值大的元素,搜索到即停止,并记录指针的位置;

  Step4.交换当前左边指针位置和右边指针位置的元素;

  Step5.重复2,3,4步骤,直到左边指针的值大于右边指针的值停止。

API设计

类名 Quick
构造方法 Quick():创建Quick对象
成员方法 1.public static void sort(Comparable[] a):对数组内的元素进行排序
2.private static void sort(Comparable[] a, int lo, int hi):对数组a中从索引lo到索引hi之间的元素 进行排序
3.public static int partition(Comparable[] a,int lo,int hi):对数组a中,从索引 lo到索引 hi之间的元 素进行分组,并返回分组界限对应的索引
4.private static boolean less(Comparable v,Comparable w):判断v是否小于w
5.private static void exch(Comparable[] a,int i,int j):交换a数组中,索引i和索引j处的值

1.代码实现

//排序代码
public class Quick {
    /*
        对数组a中的元素进行排序
    */
    public static void sort(Integer[] a){
        int lo = 0;
        int hi = a.length - 1;
        sort(a, lo, hi);
    }
    /*
        对数组a中从lo到hi的元素进行排序
    */
    public static void sort(Integer[] a, int lo, int hi){
        // 做安全性校验
        if(hi <= lo){
            return;
        }
        //对a数组中,从lo到hi的元素进行切分
        int partition = partition(a, lo, hi);
        //对左边分组中的元素进行排序
        sort(a,lo,partition-1);
        //对右边分组中的元素进行排序
        sort(a,partition+1, hi);
    }
    //对数组a中,从索引lo到索引hi之间的元素进行分组,并返回分组界限对应的索引
    public static int partition(Integer[] a, int lo, int hi){
        Integer key = a[lo];//把最左边的元素当做基准值
        int left = lo;//定义一个左侧指针,初始指向最左边的元素
        int right = hi + 1;//定义一个右侧指针,初始指向最右侧的元素下一个位置
        //进行切分
        while(true){
            //先从右往左扫描,找到一个比基准值小的元素
            while(less(key, a[--right])){//循环停止,证明找到了一个比基准值小的元素
                if(right == lo){
                    break;//已经扫描到最左边了,无需继续扫描
                }
            }
            //再从左往右扫描,找一个比基准值大的元素
            while(less(a[++left], key)){//循环停止,证明找到了一个比基准值大的元素
                if(left == hi){
                    break;//已经扫描到了最右边了,无需继续扫描
                }
            }
            if(left >= right){
                //扫描完了所有元素,结束循环
                break;
            }else{
                //交换left和right索引处的元素
                exch(a,left,right);//right就是切分的界
            }
        }
        //交换最后rigth索引处和基准值所在的索引处的值
        exch(a, lo, right);
        return right; //right就是切分的界限
    }
    /*
    数组元素i和j交换位置
    */
    private static void exch(Integer[] a, int i, int j){
        Integer t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    /*
    比较v元素是否小于w元素
    */
    private static boolean less(Integer v, Integer w){
        return v.compareTo(w) < 0;
    }
}

测试类

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
        Integer[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

2.运行结果

编写完成之后,点击运行就能知道选择排序的结果,如下图所示:


总结

快速排序和归并排序的区别

  快速排序是另外一种分治的排序算法,它将一个数组分成两个子数组,将两部分独立的排序。快速排序和归并排序 是互补的:归并排序将数组分成两个子数组分别排序,并将有序的子数组归并从而将整个数组排序,而快速排序的 方式则是当两个数组都有序时,整个数组自然就有序了。在归并排序中,一个数组被等分为两半,归并调用发生在 处理整个数组之前,在快速排序中,切分数组的位置取决于数组的内容,递归调用发生在处理整个数组之后。

时间复杂度

  如果我们把数组的切分看做是一个树,那么上图就是它的最优情况的图示,共切分了logn次,所以,最优情况下快 速排序的时间复杂度为O(nlogn);

  最坏情况:每一次切分选择的基准数字是当前序列中最大数或者最小数,这使得每次切分都会有一个子组,那么总 共就得切分n次,所以,最坏情况下,快速排序的时间复杂度为O(n^2);

  平均情况:每一次切分选择的基准数字不是最大值和最小值,也不是中值,这种情况我们也可以用数学归纳法证 明,快速排序的时间复杂度为O(nlogn),由于数学归纳法有很多数学相关的知识,容易使我们混乱,所以这里就不对 平均情况的时间复杂度做证明了。

感谢观看,如果有帮助到你,请给题解点个赞和收藏,让更多的人看到。🌹🌹🌹

也欢迎你,关注我。👍👍👍

你们的点赞和留言对我真的很重要!!! ✿✿✿

相关文章
|
存储 人工智能 算法
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
这篇文章详细介绍了Dijkstra和Floyd算法,这两种算法分别用于解决单源和多源最短路径问题,并且提供了Java语言的实现代码。
1453 3
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
|
搜索推荐 C语言
【排序算法】快速排序升级版--三路快排详解 + 实现(c语言)
本文介绍了快速排序的升级版——三路快排。传统快速排序在处理大量相同元素时效率较低,而三路快排通过将数组分为三部分(小于、等于、大于基准值)来优化这一问题。文章详细讲解了三路快排的实现步骤,并提供了完整的代码示例。
886 4
|
算法 搜索推荐
快速排序-数据结构与算法
快速排序(Quick Sort)是一种基于分治法的高效排序算法。其核心思想是通过选择基准(pivot),将数组划分为左右两部分,使得左侧元素均小于基准,右侧元素均大于基准,然后递归地对左右两部分进行排序。时间复杂度平均为 O(n log n),最坏情况下为 O(n²)(如数组已有序)。空间复杂度为 O(1),属于原地排序,但稳定性不佳。 实现步骤包括编写 `partition` 核心逻辑、递归调用的 `quickSort` 和辅助函数 `swap`。优化方法有随机化基准和三数取中法,以减少最坏情况的发生。
832 13
|
存储 搜索推荐 Python
用 Python 实现快速排序算法。
快速排序的平均时间复杂度为$O(nlogn)$,空间复杂度为$O(logn)$。它在大多数情况下表现良好,但在某些特殊情况下可能会退化为最坏情况,时间复杂度为$O(n^2)$。你可以根据实际需求对代码进行调整和修改,或者尝试使用其他优化策略来提高快速排序的性能
504 61
|
搜索推荐 C++
【C++数据结构——内排序】快速排序(头歌实践教学平台习题)【合集】
快速排序是一种高效的排序算法,基于分治策略。它的主要思想是通过选择一个基准元素(pivot),将数组划分成两部分。一部分的元素都小于等于基准元素,另一部分的元素都大于等于基准元素。然后对这两部分分别进行排序,最终使整个数组有序。(第一行是元素个数,第二行是待排序的原始关键字数据。本关任务:实现快速排序算法。开始你的任务吧,祝你成功!
492 7
|
算法 API 计算机视觉
人脸识别笔记(一):通过yuface调包(参数量54K更快更小更准的算法) 来实现人脸识别
本文介绍了YuNet系列人脸检测算法的优化和使用,包括YuNet-s和YuNet-n,以及通过yuface库和onnx在不同场景下实现人脸检测的方法。
1015 1
|
算法
❤️算法笔记❤️-(每日一刷-160、相交链表)
❤️算法笔记❤️-(每日一刷-160、相交链表)
260 1
|
JSON 算法 数据可视化
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算(目标检测)
这篇文章是关于如何通过算法接口返回的目标检测结果来计算性能指标的笔记。它涵盖了任务描述、指标分析(包括TP、FP、FN、TN、精准率和召回率),接口处理,数据集处理,以及如何使用实用工具进行文件操作和数据可视化。文章还提供了一些Python代码示例,用于处理图像文件、转换数据格式以及计算目标检测的性能指标。
511 0
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算(目标检测)
|
数据可视化 搜索推荐 Python
Leecode 刷题笔记之可视化六大排序算法:冒泡、快速、归并、插入、选择、桶排序
这篇文章是关于LeetCode刷题笔记,主要介绍了六大排序算法(冒泡、快速、归并、插入、选择、桶排序)的Python实现及其可视化过程。
456 0
|
算法
❤️算法笔记❤️-(每日一刷-83、删除排序链表中的重复项)
❤️算法笔记❤️-(每日一刷-83、删除排序链表中的重复项)
271 0