算法学习笔记(4)-快速排序

快速排序(Quick sort) 一、简介 快速排序是(Quick sort)是对冒泡排序的一种改进,是非常重要且应用比较广泛的一种高效率排序算法。 二、算法思路 快速排序是通过多次比较和交换来实现排序,在一趟排序中把将要排序的数据分成两个独立的部分,对这两部分进行排序使得其中一部分所有数据比另一部分都要小,然后继续递归排序这两部分,最终实现所有数据有序。 大致步骤如下: 首先设置一个分界值也就是基准值又是也称为监视哨,通过该分界值将数据分割成两部分。 将大于或等于分界值的数据集中到右边,小于分界值的数据集中到左边。一趟排序过后,左边部 阅读详情

一、什么是快排

快速排序是图灵奖得主 C. R. A. Hoare 于 1960 年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)。分治法的基本思想是:将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题,然后将这些子问题的解组合为原问题的解。

利用分治法可将快速排序的分为三步:

1、在数据集之中,选择一个元素作为”基准”(pivot)。
2、所有小于”基准”的元素,都移到”基准”的左边;所有大于”基准”的元素,都移到”基准”的右边。这个操作称为分区 (partition) 操作,分区操作结束后,基准元素所处的位置就是最终排序后它的位置。
3、对”基准”左边和右边的两个子集,不断重复第一步和第二步,直到所有子集只剩下一个元素为止。

二、基本实现

2.1、基本思路

假设现在有以下待排序的数组:

i -> 012345j-> 6
7891629

上面的一栏表示索引,下面的一栏表示数值

1、首先,确定左索引指针为i = 0(之后简称为指针),右指针为j = 6,基数为base,首先可以确定基数为最左边的数,即base=7

2、排序开始时,j指针从右往左走,当指到小于等于基数的数时停下,即此时j=5;i指针从左往右走,找到大于等于基数的数时停下,即i=1

0i -> 1234j-> 56
7891629

3、此时i,j两者的数值交换,即得如下

0i -> 1234j-> 56
7291689

4、重复第2、3步,得

01i -> 23j->456
7261989

5、i、j指针相遇

012i-> 3 <-j456
7261989

6、i、j指针同时指向3索引,此时用i索引的位置去交换基准值

012i-> 3 <-j456
1267989

就这样,第一次排序即完成了,此时索引3左边的值都小于等于7,右边的值都大于等于7
7、分治递归
完成了以上之后,将7左边的数视为“左数组”,右边的数视为“右数组”,重复调用1~7步,直到数组中只含一个数为止,终止递归调用

012
126
456
989
2.2、代码实现
public void sort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        quickSort(array, left, right);
    }

    private void quickSort(int[] array, int left, int right) {
        // 递归终止条件
        if (left >= right) {
            return;
        }
        // 先进行第一部分排序,获取到已排序的分割索引
        int index = partition1(array, left, right);

        // 进行左右两个部分的排序
        quickSort(array, left, index - 1);
        quickSort(array, index + 1, right);
    }
    /*
     * @Author ARong
     * @Description 快排基础版本,选择left为基准,但是如果本身已经有序,那么时间复杂度退化为O(n)
     * @Date 2019/11/27 1:32 下午
     * @Param
     * @return
     **/
    private int partition1(int[] array, int left, int right) {
        // 定义基准
        int base = array[left];
        // 定义左右指针
        int i = left, j = right;
        while (i < j) {
            // j向左寻找比基准小的数
            while (i < j && array[j] >= base) {
                j--;
            }
            // i向右寻找比基准大的数
            while (i < j && array[i] <= base) {
                i++;
            }
            // 交换i, j
            swap(array, i, j);
        }
        // 交换left, i
        swap(array, left, i);
        return i;
    }

    private void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

三、优化快排

上一版的快排并不是最优化的快排,快排的平均复杂度O(nlogn)针对的是数据重复少且几乎无序的状态,有以下几个原因会让快排退化:

时间复杂度退化的原因
快排的平均时间复杂度为O(nlogn),这时在数据量较大且重复少、几乎无序的情况下。有两种情况会导致快排的时间复杂度退化到O(n^2):
1、数组近乎有序:

当数组近乎有序的时候,时间复杂度退化到O(n^2),因为每次都取第一个元素作为基准的话,会出现无法均匀分割数组,从而使分割的数组变成链表状:
在这里插入图片描述
这时的解决办法是在数组中选取一个随机数作为基准,而不是取第一个数,这样子就能很好地避免在数组有序的情况下不能均匀切分数组的问题:

取随机数作为基准
public void sort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        quickSort(array, left, right);
    }



    private void quickSort(int[] array, int left, int right) {
        // 递归终止条件
        if (left >= right) {
            return;
        }
        // 先进行第一部分排序,获取到已排序的分割索引
        int index = partition2(array, left, right);

        // 进行左右两个部分的排序
        quickSort(array, left, index - 1);
        quickSort(array, index + 1, right);
    }




    /*
     * @Author ARong
     * @Description 快排升级版本,随机选择基准,避免快排退化为O(n)
     * @Date 2019/11/27 1:32 下午
     * @Param
     * @return
     **/
    private int partition2(int[] array, int left, int right) {
        // 随机定义基准
        int randomIndex = left + new Random().nextInt(1000) % (right - left + 1);
        // 将随机基准和left交换
        swap(array, left, randomIndex);
        // 选取基准
        int base = array[left];
        // 定义左右指针
        int i = left, j = right;
        while (i < j) {
            // j向左寻找比基准小的数
            while (i < j && array[j] >= base) {
                j--;
            }
            // i向右寻找比基准大的数
            while (i < j && array[i] <= base) {
                i++;
            }
            // 交换i, j
            if (i < j) {
                swap(array, i, j);
            }
        }
        // 交换left, i
        swap(array, left, i);
        return i;
    }

2、大数据量的数据重复:
当数组中的数据大量重复时,会出现分配不均匀问题切分不均匀问题,导致快排时间复杂度退化到O(n^2)
在这里插入图片描述
有一个思路非常常用,被称为三路快排,它的思想是将数组切分为三个部分:第一个部分小于baes,第二个部分等于base,第三个部分大于base,在下一次的迭代中,将小于base的部分继续排序,大于base的部分继续排序即可

三路快排
/**
 * @Auther: ARong
 * @Date: 2019/11/27 5:41 下午
 * @Description: 三路快排,优化大量重复元素的情况
 */
public class _3_QuickSort3Ways {
    @Test
    public void fun() {
        int[] array = new int[10];
        for (int i = 0; i < array.length; i++) {
            array[i] = new Random().nextInt(10);
        }
        System.out.println(Arrays.toString(array));
        quickSort3Ways(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));
    }


    public void quickSort3Ways(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        // 获取随机索引并设置基准值
        int randomIndex = left + new Random().nextInt(1000) % (right - left + 1);
        swap(array, left, randomIndex);
        int base = array[left];
        // 定义i,j和cur
        // [left + 1, i] < base
        // [i + 1, cur - 1] == base
        // [j, right] > base
        int i = left, j = right + 1, cur = left + 1;
        while (cur < j) {
            if (i < j && array[cur] < base) {
                swap(array, i + 1, cur);
                i++;
                cur++;
            } else if (i < j && array[cur] > base) {
                swap(array, cur, j - 1);
                j--;
            } else if (i < j && array[cur] == base) {
                cur++;
            }
        }
        swap(array, left, i);
        // 划分两个子数组
        quickSort3Ways(array, left, i - 1);
        quickSort3Ways(array, j, right);
    }


    private void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

四、性能对比

先用一千万个范围在0~1000的数组进行排序对比普通快排和三路快排的速度:

   public static void main(String[] args) {
       //生成数据量
       int n = 10000000;
       int[] a = new int[n];
       //取值区间
       int k = 1000;
       for (int i = 0; i < n; i++) {
           a[i] = (int) (Math.random() * k);
       }

       long beginTime = new Date().getTime();

       QuickSortNormal.quickSort(a, 0, a.length - 1);

       long endTime = new Date().getTime();
       System.out.println("用时:" + (endTime - beginTime) + "毫秒"); quickSort(a, 0, a.length - 1);

   }

普通快排
在这里插入图片描述
三路快排
在这里插入图片描述
从实验结果可以看出,三路快排在千万级大重复数据量的情况下仍能在1s内进行排序,而普通快排花了27s,性能相差有27倍之多.

《排序算法篇》快排的递归与非递归 快排的思想 实现单趟快排的三种方式(hoare、挖坑、前后指针) 递归实现快排 对快排进行优化(三数取中,小区间优化) 非递归实现快排(栈或队列实现) 阅读详情

相关推荐

快排(动图详细版,快速理解)

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法,其基本思想为:任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。

weixin_73584362的博客 6565

快速排序(QuickSort)算法介绍

算法简介快速排序(Quicksort)是对冒泡排序的一种改进算法。由C. A. R. Hoare在1960年提出。该算法使用广泛、效率很高,是最重要的排序算法之一。该算法的实现基本可分为以下几步:

wthfeng的专栏 6万+

算法介绍——快速排序

快速排序 快速排序是最常用的排序算法。 举例说明 假设我们要对 “6 1 2 7 9 3 4 5 10 8” 这 10 个数进行排序。 C代码实现 # 复杂度分析

程序员「阿基米东」的编程之旅 4万+

快排算法(分治法)

当right找到了比privot小的数我们就停止对他的移动,然后移动我们的left,同理,如果left遇到的数小于privot我们就不用管,直到遇到大于privot的数就停止。设我们接下来需要对小堆进行排序,对小堆进行排序的话也就是当前的右下标指向的值不能超过privot,我们就可以让右下表指向right-1的位置,然后再把L和right-1再传给这个函数它继续对剩下的值进行排序,当最后只有一个数的时候我们认为它就是有序的。交换之后的数组就变成了左边全是小于privot的数,右边全是大于privot的数。

Trustmeican的博客 4714

从零到英雄:WSL2与Ubuntu22.04的终极性能调优指南

本文详细介绍了如何在Windows系统中通过WSL2与Ubuntu22.04进行性能调优,涵盖内核定制、GPU加速、网络优化等关键技巧,帮助开发者打造媲美原生Linux的高性能开发环境,特别适合AI训练和大数据处理等资源密集型任务。

weixin_29218509的博客 524

【COMSOL超材料和超表面仿真设计】

超材料和超表面的设计通常需要自定义材料属性。在COMSOL中,可以通过定义介电常数和磁导率的张量来模拟超材料的特性。对于超表面,通常需要定义表面阻抗或等效电路模型。

weixin_51101456的博客 1677

《算法图解》学习笔记—第4章 快速排序

4.1 分而治之 分而治之(divide and conquer,D&C)——一种著名的递归式问题解决方法。D&C并非可用于解决问题的算法,而是一种解决问题的思路。D&C的工作原理: (1) 找出简单的基线条件; (2) 确定如何缩小问题的规模,使其符合基线条件。 示例:给定一个数字数组,需要将这些数字相加,并返回结果。 使用循环很容易完成这种任务。 def sum(arr): total = 0 for x in arr: total += x

weixin_38615776的博客 231

ISCE+Mintpy进行SBASInSAR处理(持续更新)

通过调用pairs_misregistration方法,利用safe_dict中的数据信息,对每对SLC数据进行配准误差的计算和分析,以确定数据之间的精确差异,为后续的时间序列处理提供基础。给定同一地区的两景SAR影像,经过配准之后,对应像元进行共轭相乘得到相位差,并形成干涉图,但是从干涉图中得到的相位差实际上是主值,即在(-π,π)呈周期性变化,为了还原其真实的相位差,必须在主值的基础上加或减整数倍的相位周期2π,把被卷叠的相位展开,才能顺利地反演出地面目标的高程和形变。

Cyy2511250589的博客 3737

【Algorithms 4】算法(第4版)学习笔记 06 - 2.3 快速排序

《算法(第4版)》2.3 快速排序 学习笔记。包括:快速排序和三向切分快速排序。

MichelleChung的星球 1514

博途PLC如何建立与笔记本电脑端的连接?(新手必会)

对S7-1500PLC下载硬件组态或程序,需要建立PC与PLC的连接。 由于S7-1500CPU都具有PN端口,因此建立PC与S7-1500PLC的连接通常使用工业以太网来实现。 1.使用网线连接PC-PLC 使用网线,一端连接PC的以太网卡端口,另一端连接S7-1500CPU的PN端口。 2.设置本机IP地址 2.1 确认本机要设置的IP地址段 本机IP地址要和PLC程序组态IP地址段前三位保持一致,后一位使用组态中没有用到的IP地址段。如下图所示。 那么看了这个图片应该就知道了,地址应该设置成192.

weixin_42430971的博客 1万+

代码接单:用 ComfyUI 搭建电商模特换装工作流(保姆级教程)

在闲鱼和小红书上,搜一下“AI 模特图”或者“服装换模特”,你会发现大量的接单需求。太贵:请个外模拍一套图,动辄几千块。太慢:寄样品、排期、拍摄、修图,半个月过去了。太卷:竞对都在上新,你还在等图。“给我一张你的衣服平铺图(或假人图),我 10 分钟给你生成真人上身图,一张只要 50 块。对于商家是省钱,对于你是纯利润。为什么不用 Midjourney?因为 MJ 抽卡不可控,无法保持衣服版型一致。只有 ComfyUI,才能做到精准控制,实现工业化量产。

BUG猿的博客 1784

算法学习笔记4-经典快速排序/随机排序

快速排序

qq_45205390的博客 428

【C语言】字符常量详解

字符常量是C语言中处理字符数据的重要工具。通过单引号括起一个字符,我们可以方便地使用字符常量进行字符判断、字符运算和字符串处理等操作。理解字符常量的表示方法、使用场景和ASCII码对应关系,对于编写高效的C语言程序至关重要。

LuckiBit 5022

Linux C学习笔记-排序算法4-快速排序

快速排序 设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用第1个数据)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。 排序步骤 一趟快速排序的算法是: 1)设置两个变量i、j,排序开始的时候:i=0,j=N

我在学C语言 1226

使用PostgreSQL构建高可用数据库集群

在现代企业级应用中,数据库的高可用性已成为业务连续性的核心要求。PostgreSQL作为一款功能强大的开源关系型数据库,其高可用架构的设计直接影响着系统的稳定性和可靠性。

九天的专栏 1261

Prometheus+Grafana+alertmanager+PrometheusAlert监控告警 实现飞书告警

以上 是以grafana做的邮件告警,但是感觉邮件很少人看。下面是以webhook 可以接入。启动alertmanager (设置 开机在启动)下载prometheusalter 配置文件。这里的告警是基于grafana上搭建的。我们启动PrometheusAlert。写完之后进行重启Prometheus。prometheus 的告警规则。测试 基于我们生产环境做的文档。然后在grafana上导模板。上导入模板就可以 直接引用。访问 grafana页面。重启一下grafana。

墨痕诉清风的博客 859

经典算法(4)图解快速排序算法及代码实现

很多软件公司的笔试和面试,像腾讯,微软等知名IT公司都喜欢考这个,还有大大小的程序方面的考试如软考,考研中也常常出现快速排序的身影。这篇博客用图解的形式对快速排序过程做了说明,并且有完整的代码实现。

扬帆向海的博客 4万+

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

快速排序算法

  快速排序(Quick sort)是对冒泡排序算法的一种改进。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。   快速排序算法是最流行的排序算法,也是速度最快的排序算法。   快速排序算法通过多次比较和交换来实现排序,其排序流程如下: 首先设定一个分界值,通过该分界值将数组分成左右两部分; 将大于或等于分界值的数据集中到数组右边,小于分

大彤小忆的博客 6455

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

快速排序算法原理

1.快速排序算法是什么? 想必大家都学过和用过冒泡排序吧!这应该是大家成为程序员道路上学的第一个算法哦,那么我们的快速排序算法其实是在冒泡排序的基础上的一个改进,快速排序算法是利用一趟快速排序,一趟快排一般都是取第一个数作为准基数进行排序,将一串数据分成两个部分, 第一部分都比准基数小,第二部分都比准基数大,如:(-------第一部分------准基数------第二部分),也就这样以准...

Mr_xiayijie的博客 1万+

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

《算法图解》-4 快速排序

本文属于《图解算法》系列。 一 分而治之 分而治之(devide and conquer)是递归思路是常见的解决方式。 作者以划分土地为例子,介绍这个思路: 换个思路,这是数学上典型的求两个数的最大公约数(GCD)的问题。 这里重申一下D&C的工作原理: (1) 找出简单的基线条件; (2) 确定如何缩小问题的规模,使其符合基线条件。 下面是Java...

bohu83的博客 2309

排序算法(4)之快速排序(1)

排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.

wer24_25的博客 1760

快速排序算法与舍伍德快速排序算法

排序算法是比较常见的算法,道理也比较简单,双指针法。今天被朋友问了个舍伍德排序算法,也是快速排序那种形式。尴尬,第一次听说,特意学了一下。结合快速排序,写了三个方法。 第一种: //不需要将基准值归位的快速排序 public static void quickSort(int []a,int left,int right) { if(left>=right) return ; int ...

大鹏视界U 3834

算法图解part4:快速排序

算法图解part4:快速排序1.分而治之 D&C(Divide and Conquer)1.1农场主分田1.2数组之和2.快速排序3.再谈大O表示法4.总结5.参考资料 1.分而治之 D&C(Divide and Conquer) 百度百科 所谓“分而治之” 就是把一个复杂的算法问题按一定的“分解”方法分为等价的规模较小的若干部分,然后逐个解决,分别找出各部分的解,把各部分的解组成...

catkin_ws的博客 1729

【算法】快速排序算法原理及实现

快速排序算法原理及实现

互联网小阿祥 3547

算法学习笔记之快速排序

算法学习笔记之快速排序 快速排序算法原理 以数组第一个位置上的元素为切分元素, 定义左扫描 i 和 右扫描 j, 左扫描 i 从左向右扫描,直到扫描到小于切分元素的元素停止,右扫描 j 从右向左扫描,直到扫描到大于切分元素的元素停止 左扫描和右扫描都停止,交换位置 第一轮结束后,交换 i 或者 j 与切分元素的位置,此时, i 或者 j 位置左边都是小于切分元素,右边都是大于切分元素 以切分元...

SIMBA1949的博客 358
上一篇: Java基础(3)-注解总结
下一篇: 数据结构(4)-链表(2)
BoringRong
BoringRong 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄9年 2万+粉丝 386原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BoringRong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值