2024年快速排序图解（两种思想）_如何找出数组的分区点(3)，2024年最新深入理解大数据动画原理

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

七大排序之快速排序

文章目录

• 七大排序之快速排序
• 前言
• 一、《算法导论》中的分区思想
• • 1.1 算法思想
    • 1.2 代码实现
• 二、Hoare挖坑法
• • 2.1 算法思想
    • 2.2 代码实现
• 三、算法分析
• 四、注意事项
• 总结

---

前言

博主个人社区：开发与算法学习社区

博主个人主页：Killing Vibe的博客

欢迎大家加入，一起交流学习~~

一、《算法导论》中的分区思想

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

动图如下：

1.1 算法思想

快速排序是20世纪最伟大的算法之一

核心的思路就是分区

分区值：默认选择最左侧元素pivot（当然也可以随机选择）

1. 从无序区间选择一个值作为分界点pivot开始扫描原集合
2. 将数组中所有小于该pivot的元素放在分界点左侧
3. 大于等于该元素的值放在分区点的右侧
4. 经过本轮交换，pivot放在了最终位置，pivot的左侧都是小于该值的元素，pivot的右侧都是大于该值的元素，在这两个子区间重复上述过程，直到整个集合有序。

举个栗子：

1.若arr[i] >= v

2.若arr[i] < v

索引 j 指向了最后一个 < v 的元素，而 j+1 恰好是第一个 >= v的元素

3.当 i 扫描完集合时，数组划分如下：

4.交换 l 和 j 所在的元素

5.橙色和紫色的部分继续重复上述过程即可

1.2 代码实现

代码如下：（请往后看）

    private static void quickSortInternal(int[] arr, int l, int r) {
        // 2.小区间上使用插入排序来优化，不用递归到底
        if (r - l <= 15) {
            insertionSort(arr,l,r);
            return;
        }
        int p = partition(arr,l,r);
        // 继续在左右两个子区间进行快速排序
        // 所有 < v的元素
        quickSortInternal(arr,l,p - 1);
        // 所有 >= v的元素
        quickSortInternal(arr,p + 1,r);
    }

    private static int partition(int[] arr, int l, int r) {
        // 1.优化1.使用一个随机位置作为分区点，避免快排在近乎有序数组上的性能退化
        int randomIndex = random.nextInt(l,r);
        swap(arr,l,randomIndex);
        int v = arr[l];
        // arr[l + 1..j] < v
        // 最开始区间没有元素
        int j = l;
        // arr[j + 1..i) >= v
        // 最开始大于区间也没有元素
        for (int i = l + 1; i <= r; i++) {
            if (arr[i] < v) {
                swap(arr,i,j + 1);
                j ++;
            }
        }
        // 此时元素j就是最后一个 < v的元素，就把v换到j的位置
        swap(arr,l,j);
        return j;
    }

注意：这是优化后的代码

小数组采用插入排序可以提高性能，若不能理解可以把这段改成：

 if (r - l <= 0) return;  

非递归写法：

    public static void quickSortNonRecursion(int[] arr) {
        Deque<Integer> stack = new ArrayDeque<>();
        // r
        stack.push(arr.length - 1);
        // l
        stack.push(0);
        // 每次从栈中取出两个元素，这辆个元素就是待排序区间的l..r
        while (!stack.isEmpty()) {
            int l = stack.pop();
            int r = stack.pop();
            if (l >= r) {
                // 当前子数组已经处理完毕
                continue;
            }
            int p = partition(arr,l,r);
            // 继续入栈两个子区间
            stack.push(p - 1);
            stack.push(l);

            stack.push(r);
            stack.push(p + 1);
        }
    }

    private static int partition(int[] arr, int l, int r) {
        // 1.优化1.使用一个随机位置作为分区点，避免快排在近乎有序数组上的性能退化
        int randomIndex = random.nextInt(l,r);
        swap(arr,l,randomIndex);
        int v = arr[l];
        // arr[l + 1..j] < v
        // 最开始区间没有元素
        int j = l;
        // arr[j + 1..i) >= v
        // 最开始大于区间也没有元素
        for (int i = l + 1; i <= r; i++) {
            if (arr[i] < v) {
                swap(arr,i,j + 1);
                j ++;
            }
        }
        // 此时元素j就是最后一个 < v的元素，就把v换到j的位置
        swap(arr,l,j);
        return j;
    }

可运行版本：

public class Test {
    static Random random = new Random();
    public static void main(String[] args) {
        int[] arr = new int[]{4,5,8,2,1,3,7,6};

        quickSort(arr,0,arr.length-1);

        for(int i =0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    private static void quickSort(int[] arr,int l,int r) {
        if(l>=r){
            return;
        }
        int p = partition(arr,l,r);
        quickSort(arr,l,p-1);
        quickSort(arr,p+1,r);
    }

    private static int partition(int[] arr, int l, int r) {
        int randomIndex = random.nextInt(r-l)+l;
        swap(arr,l,randomIndex);
        int v = arr[l];
        int j = l;  //j是<v的最后一个元素
        for(int i = l+1;i<=r;i++){
            if(arr[i]<v){
                swap(arr,i,j+1);
                j++;
            }
        }
        swap(arr,l,j);
        return j;
    }

    private static void swap(int[] arr, int l, int randomIndex) {
        int temp;
        temp = arr[l];
        arr[l] = arr[randomIndex];
        arr[randomIndex] = temp;
    }
}

二、Hoare挖坑法

目前市面上和教科书上的常用分区方法。

2.1 算法思想

1. 先从序列中随机选一个pivot，默认从最左边元素
2. 将两个索引 i 和 j 分别从左右两边开始往中间遍历
3. 先让 j 从后往前找到第一个 < v 的元素停止，把这个元素直接赋值给i所对应得元素。
4. 再让 i 从前往后找到第一个 > v 的元素停止
5. 当 i 和 j 重合时，arr[i] = pivot 即可~

没有元素交换的时候都是直接赋值，理论上会减少因为交换带来的时间损耗

2.2 代码实现

代码如下：

    private static void quickSortInternalHoare(int[] arr, int l, int r) {
        // 2.小区间上使用插入排序来优化，不用递归到底
        if (r - l <= 15) {
            insertionSort(arr,l,r);


![img](https://img-blog.csdnimg.cn/img_convert/6c5dcee92339940962f2151dcc163c0a.png)
![img](https://img-blog.csdnimg.cn/img_convert/cebbfc30c72f062aaedcbea8ef0197e8.png)
![img](https://img-blog.csdnimg.cn/img_convert/7955ce32b4219088316aa68f292ec667.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

片转存中...(img-doL4DrYZ-1715626853855)]
[外链图片转存中...(img-i1zX1EIT-1715626853855)]
[外链图片转存中...(img-fSY0FCTU-1715626853855)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**