面试：java 快速排序

已于 2022-08-02 10:49:56 修改
阅读量217 收藏
点赞数
分类专栏： Java日常总结 文章标签： java
于 2022-07-27 16:27:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hfaflanf/article/details/126016480
版权

**算法描述**

1. 每一轮排序选择一个基准点（pivot）进行分区
   1）让小于基准点的元素的进入一个分区，大于基准点的元素的进入另一个分区
   2）当分区完成时，基准点元素的位置就是其最终位置
2. 在子分区内重复以上过程，直至子分区元素个数少于等于 1，这体现的是分而治之的思想 （[divide-and-conquer]）
3. 从以上描述可以看出，一个关键在于分区算法，常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

**单边循环快排（lomuto 洛穆托分区方案）**

1. 选择最右元素作为基准点元素

2. j 指针负责找到比基准点小的元素，一旦找到则与 i 进行交换

3. i 指针维护小于基准点元素的边界，也是每次交换的目标索引

4. 最后基准点与 i 交换，i 即为分区位置

首先看第一轮分区的代码

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

        partition(a, 0, a.length-1);

    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[h]; // 基准点元素
        int i = l;
        for (int j = l; j < h; j++) {
            System.out.println("i=" + i + ";j=" + j);
            System.out.println(Arrays.toString(a));
            if (a[j] < pv) {
                swap(a, i, j);
                i++;
            }
            System.out.println("i=" + i + ";j=" + j);
            System.out.println(Arrays.toString(a));
            System.out.println("------------------------");
        }
        swap(a, h, i);
        System.out.println(Arrays.toString(a));
        // 返回值代表了基准点元素所在的正确索引，用它确定下一轮分区的边界
        return i;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
i=0;j=0
[5, 3, 7, 2, 9, 8, 1, 4]
i=0;j=0
[5, 3, 7, 2, 9, 8, 1, 4]
------------------------
i=0;j=1
[5, 3, 7, 2, 9, 8, 1, 4]
i=1;j=1
[3, 5, 7, 2, 9, 8, 1, 4]
------------------------
i=1;j=2
[3, 5, 7, 2, 9, 8, 1, 4]
i=1;j=2
[3, 5, 7, 2, 9, 8, 1, 4]
------------------------
i=1;j=3
[3, 5, 7, 2, 9, 8, 1, 4]
i=2;j=3
[3, 2, 7, 5, 9, 8, 1, 4]
------------------------
i=2;j=4
[3, 2, 7, 5, 9, 8, 1, 4]
i=2;j=4
[3, 2, 7, 5, 9, 8, 1, 4]
------------------------
i=2;j=5
[3, 2, 7, 5, 9, 8, 1, 4]
i=2;j=5
[3, 2, 7, 5, 9, 8, 1, 4]
------------------------
i=2;j=6
[3, 2, 7, 5, 9, 8, 1, 4]
i=3;j=6
[3, 2, 1, 5, 9, 8, 7, 4]
------------------------
[3, 2, 1, 4, 9, 8, 7, 5]

 注意 i、j 的值，以及数组的变化

一轮分区以后，数组变成了[3, 2, 1, 4, 9, 8, 7, 5]，发现基准点左侧，都是比它小的，右侧都是比它大的

对基准点左侧子分区及右侧子分区，改变左右边界，继续进行分区操作，以此类推，直到区间内元素个数<=1时，就表示这个区间是有序的了

添加递归

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

        quick(a, 0, a.length-1);

        System.out.println(Arrays.toString(a));
    }

    public static void quick(int[] a, int l, int h) {
        if (l >= h) {
            return;
        }
        int p = partition(a, l, h); // p 索引值
        quick(a, l, p - 1); // 左边分区的范围确定
        quick(a, p + 1, h); // 左边分区的范围确定
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[h]; // 基准点元素
        int i = l;
        for (int j = l; j < h; j++) {
            if (a[j] < pv) {
                swap(a, i, j);
                i++;
            }
        }
        swap(a, h, i);
        // 返回值代表了基准点元素所在的正确索引，用它确定下一轮分区的边界
        return i;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
[1, 2, 3, 4, 5, 7, 8, 9]

**双边循环快排（不完全等价于 hoare 霍尔分区方案）**

1. 选择最左元素作为基准点元素
2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i，j 相交
3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置

首先看第一轮分区操作

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

        partition(a, 0, a.length-1);
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            System.out.println("i=" + i + ";j=" + j);
            System.out.println(Arrays.toString(a));
            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            // i 从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }
            System.out.println("i=" + i + ";j=" + j);
            swap(a, i, j);
            System.out.println(Arrays.toString(a));
            System.out.println("-------------------------");
        }
        swap(a, l, j);
        System.out.println(Arrays.toString(a));
        return j;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
i=0;j=7
[5, 3, 7, 2, 9, 8, 1, 4]
i=2;j=7
[5, 3, 4, 2, 9, 8, 1, 7]
-------------------------
i=2;j=7
[5, 3, 4, 2, 9, 8, 1, 7]
i=4;j=6
[5, 3, 4, 2, 1, 8, 9, 7]
-------------------------
i=4;j=6
[5, 3, 4, 2, 1, 8, 9, 7]
i=4;j=4
[5, 3, 4, 2, 1, 8, 9, 7]
-------------------------
[1, 3, 4, 2, 5, 8, 9, 7]

分区操作的结果是所有的比基准点小元素的在左边，所有比基准点大元素的在右边

添加上递归

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

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

    private static void quick(int[] a, int l, int h) {
        if (l >= h) {
            return;
        }
        int p = partition(a, l, h);
        quick(a, l, p - 1);
        quick(a, p + 1, h);
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            // i 从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }
            swap(a, i, j);
        }
        swap(a, l, j);
        System.out.println(Arrays.toString(a) + " j=" + j);
        return j;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
[1, 3, 4, 2, 5, 8, 9, 7] j=4
[1, 3, 4, 2, 5, 8, 9, 7] j=0
[1, 2, 3, 4, 5, 8, 9, 7] j=2
[1, 2, 3, 4, 5, 7, 8, 9] j=6

要点

1. 基准点在左边，并且要先 j 后 i

2. while( **i** **< j** && a[j] > pv ) j-- 
3. while ( **i** **< j** && a[i] **<=** pv ) i++

疑问一，为什么 i 在从左往右，找大的的时候，需要 a[i] <= pv ，而 j 从右往左找小的的时候，不需要

a[j] > pv？

假如是这样 a[i] < pv，没有 =，执行代码，就会出现这个结果

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

        partition(a, 0, a.length-1);
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            System.out.println("i=" + i + ";j=" + j);
            System.out.println(Arrays.toString(a));
            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            // i 从左找大的
            while (i < j && a[i] < pv) {
                i++;
            }
            System.out.println("i=" + i + ";j=" + j);
            swap(a, i, j);
            System.out.println(Arrays.toString(a));
            System.out.println("-------------------------");
        }
        swap(a, l, j);
        System.out.println(Arrays.toString(a));
        return j;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
i=0;j=7
[5, 3, 7, 2, 9, 8, 1, 4]
i=0;j=7
[4, 3, 7, 2, 9, 8, 1, 5]
-------------------------
i=0;j=7
[4, 3, 7, 2, 9, 8, 1, 5]
i=2;j=7
[4, 3, 5, 2, 9, 8, 1, 7]
-------------------------
i=2;j=7
[4, 3, 5, 2, 9, 8, 1, 7]
i=2;j=6
[4, 3, 1, 2, 9, 8, 5, 7]
-------------------------
i=2;j=6
[4, 3, 1, 2, 9, 8, 5, 7]
i=4;j=6
[4, 3, 1, 2, 5, 8, 9, 7]
-------------------------
i=4;j=6
[4, 3, 1, 2, 5, 8, 9, 7]
i=4;j=4
[4, 3, 1, 2, 5, 8, 9, 7]
-------------------------
[5, 3, 1, 2, 4, 8, 9, 7]

在第一轮分区，第一次遍历时，错误的把基准点元素交换掉了

疑问二，为什么有了外层的 while (i < j) ，内层还需要判断 i < j ？

假设没有i < j 判断，有数组[5, 1, 2, 3, 7, 8, 9] 对它就行分区操作，j 从右向左找小的，到了 2 停下，i 从左向右找大的，到7停下，交换，数组就变成了[5, 1, 7, 3, 2, 8]

i < j 判断，确保了所有的比基准点小元素的在左边，所有比基准点大元素的在右边

疑问三，目前是先运行 j ，后运行 i ，二者的顺序是够可以调换？

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};

        partition(a, 0, a.length-1);
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            System.out.println("i=" + i + ";j=" + j);
            System.out.println(Arrays.toString(a));
            // i 从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }

            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            System.out.println("i=" + i + ";j=" + j);
            swap(a, i, j);
            System.out.println(Arrays.toString(a));
            System.out.println("-------------------------");
        }
        swap(a, l, j);
        System.out.println(Arrays.toString(a));
        return j;
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

控制台输出：
i=0;j=7
[5, 3, 7, 2, 9, 8, 1, 4]
i=2;j=7
[5, 3, 4, 2, 9, 8, 1, 7]
-------------------------
i=2;j=7
[5, 3, 4, 2, 9, 8, 1, 7]
i=4;j=6
[5, 3, 4, 2, 1, 8, 9, 7]
-------------------------
i=4;j=6
[5, 3, 4, 2, 1, 8, 9, 7]
i=5;j=5
[5, 3, 4, 2, 1, 8, 9, 7]
-------------------------
[8, 3, 4, 2, 1, 5, 9, 7]

发现分区有误

**快排特点**

1. 平均时间复杂度是 $O(nlog_2⁡n )$，最坏时间复杂度 $O(n^2)$

2. 数据量较大时，优势非常明显

3. 属于不稳定排序

六千江山
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序——快速排序
qq_46002941的博客
03-29 510
文章目录快速排序1. 单边快速排序（lomuto洛穆托分区方案）1.1**一轮排序代码实现**1.2 **完成递归调用**1.3 **优化两个小点**2. **双边循环快排（并不完全等价于 hoare 霍尔分区方案）**2.1 **代码实现 **2.2 双边循环的几个要点3. 快速排序-特点 快速排序 文字描述 每一轮排序选择一个基准点（pivot）进行分区 让小于基准点的元素进入一个分区，大于基准点的元素进入另一个分区 当分区完成时，基准点元素的位置就是其最终位置 在子分区内，重复以上过程，直至子
快速选择算法——关于Lomuto划分的Quick selects算法Python实现
白片片的博客
04-09 3133
选择问题是求一个n个数列表的第k个最小元素的问题。这个数字被成为第k个顺序统计量。对于k=1或k=n，问题退化为最小和最大元素问题。显然，为了找出第k个最小的元素，我们可以先对数组排序，然后再从输出中找出第k个元素。但是，杀鸡需用牛刀？只是找第k个最小元素，我们并不需要排序（除非查询的次数很多，并且每次k都不一样，但那是属于预排序优化的内容了，后面会讲），我们可以采用划分（parti...
使用lomuto划分实现快速选择算法Java版
D_wang1的博客
04-10 1335
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录使用lomuto划分实现选择算法(Java版含伪代码)一、lomuto划分的原理与实现1.lomuto划分的原理2.Lomuto划分的伪代码实现二、基于划分的递归算法解决选择问题1.快速选择(quickselect)算法的实现原理2.快速选择(quickselect)伪代码实现3.快速选择的时间效率三、基于Lomuto划分实现快速选择算法（java实现代码） 使用lomuto划分实现选择算法(Java版含伪代码) 本文是对《算法设
java 快速排序_JAVA面试题：5分钟了解快速排序
weixin_39958248的博客
12-02 254
前言快速排序是面试中经常会问到的一种排序算法，对比其他一些排序算法，快速排序的平均时间相对较少。快速排序思想介绍快速排序使用了分治的思想，通过一轮的排序，可以将序列分割成独立的两个部分，其中一部分的值均比基准值小，另一部分的值均比基准值大。而后针对两部分序列再分别按照同样的算法进行排序，直到序列整体有序。以如下序列arr为例进行升序排序，说明快速排序的基本算法第一个位置的值23作为基准值base，...
C语言算法--快速排序法
南山府的博客
05-18 4765
Lomuto分区是一种用于快速排序算法的分区方法，由C.A.R. Hoare的经典分区方法之一。Lomuto分区算法的实现相对简单，但在某些情况下效率稍低。选择一个基准元素。通常情况下，选择数组的最后一个元素作为基准元素。遍历数组，将小于等于基准元素的元素放在数组的左边，并维护一个指针（称为分区指针），指向当前小于等于基准元素的位置。遍历结束后，将基准元素放在分区指针的下一个位置，即将基准元素放在正确的位置上。分区指针左边的元素都小于等于基准元素，右边的元素都大于基准元素。
H马Java面试专题课
04-11
│ 25-快速排序_单边循环(lomuto)_演示.mp4 │ 26-快速排序_单边循环(lomuto)_实现_分区.mp4 │ 28-快速排序_双边循环_演示.mp4 │ 31-快速排序_特点.mp │ 35-Iterator_FailSafe_源码分析.mp4 │ 36-...
《JAVA面试题》--数据结构（链表、队列、栈、二叉树、哈希表等）以及一些常用的算法排序：归并、快速排序、基数排序等.zip
04-02
十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA...
数据结构、算法及常见面试题：java实现.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
冒泡排序-Java 版本
最新发布
04-24
附件包含用 Java语言编写的冒泡排序源码，是面试中非常常见的算法题，绿色安全，下载即可使用！
java抢票软件源码-interview:java面试题整理
06-05
基本类型数据使用快速排序法，对象数组使用归并排序。 String,StringBuffer和StringBuilder的区别； 解答: Object的方法有哪些：比如有wait方法，为什么会有； 解答: wait和sleep的区别，必须理解！！！ 解答: 强...
“划分”思想，Lomuto划分（单向）
Scl_Diligent的博客
10-23 1283
Lomuto划分，将数组分为连续的三段，一段为已知(以p为基数划分)的元素，一段为已知的元素，还有一段过的元素。（算法初始前两段为空）
java面试算法汇总-排序问题
zlsd21的博客
03-10 283
排序问题
java面试算法之快速排序
luoluo01的博客
09-02 373
快速排序是效率比较高的排序算法之一，其主要用的思想就是分治法（分而治之） 完成递归排序。 快速排序的步骤包含以下三个步骤： 1.获取基准值 2.获取分割位置 partition同时对数组内元素大于基准值的放放右边，小于的放左边 3.最后递归实现调用 拆分数组first-partition partition-last 重复1,2步骤即可完成数组的排序 （面试需要所以写的相当匆忙 后续有时
java面试中常用的排序算法
热门推荐
懒虫一个V
09-07 1万+
一、冒泡排序package sort.bubble; import java.util.Random; /** * 依次比较相邻的两个数，将小数放在前面，大数放在后面 * 冒泡排序，具有稳定性 * 时间复杂度为O（n^2） * 不及堆排序，快速排序O（nlogn，底数为2） * @author liangge * */ public class Main { public static void main(String[] args) { Random ran =
java 快速排序_开发面试题之快速排序（QuickSort）的Java实现
weixin_39703561的博客
12-02 169
快速排序(QuickSort)的Java实现简介快速排序，看这名字就知道这是一种很快的排序方法，实际上也是如此。快速排序属于分治法的一种，就是说通过把数据分成几部分来同时处理的一种算法。快速排序的步骤我们以数组int[]a={7,5,3,2,9,10,8,4,6,1};这个数组为例来说明一下快速排序到底是怎么进行的。第1步：找基准值所谓的基准值，顾名思义就是以它为基准进行比大小。通常来说，我们选取...
Java实现几种常见排序方法
酌一壶茶，写一段代码
06-01 1万+
日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。 /** * 冒泡法排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为
JavaEE-面试-POI面试回答思路
billycoder的专栏
03-24 4401
是什么？ Apache POI是Apache开源的,可以通过Java读写word和excel。 ## 难不难？ 不难 它的出现解决什么问题？ 导出word或者excel（报表），方便数据查看。 导入word或者excel，方便数据录入。 提供了编程方式控制office文档，而不仅仅是人为操作。 同类型技术？ Aspose，需要资料的同学单独联系我。 简单介绍？ 1. 基本使用 新建工作簿...
面试经典之快速排序
Hello World
05-02 5204
快速排序是前端面试中经常被问到的一个问题，这里我们借用阮一峰老师的快速排序思想《快速排序（Quicksort）的Javascript实现》 原理 在数据集之中，选择一个元素作为“基准”。 所有小于“基准”的元素，都移到“基准”的左边；所有大于“基准”的元素，都移到“基准”的右边。 对“基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。 过程 以...
快速排序 java面试题_排序都有哪几种方法?请列举。用JAVA实现一个快速排序?
weixin_31002075的博客
02-13 114
2015-01-07 06:30:01阅读( 55 )排序的方法有：插入排序(直接插入排序、希尔排序)，交换排序(冒泡排序、快速排序)，选择排序(直接选择排序、堆排序)，归并排序，分配排序(箱排序、基数排序)用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。插入排序：package org.rut.util.algori...
快速排序Java代码
08-03
快速排序是面试中常见的排序算法，写出它的代码可以展示出对基本排序算法的掌握程度。 ### 回答3： 快速排序是一种常用的排序算法，效率较高。下面是用Java编写的快速排序代码： ```java public class QuickSort ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值