2024年最新快速排序图解（两种思想）_如何找出数组的分区点，2024大厂大数据开发面试集合-CSDN博客

本文链接：https://blog.csdn.net/2401_84167046/article/details/138849108

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

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

        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;
}


**注意：这是优化后的代码**


![在这里插入图片描述](https://img-blog.csdnimg.cn/301a0d7c6175433db6e0d2b1bdd4dc3a.png)


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

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);
        return;
    }
    int p = partitionHoare(arr,l,r);
    // 继续在左右两个子区间进行快速排序
    // 所有 < v的元素
    quickSortInternalHoare(arr,l,p - 1);
    // 所有 >= v的元素
    quickSortInternalHoare(arr,p + 1,r);
}

/\*\*

* 挖坑分区法
* @param arr
* @param l
* @param r
* @return
*/
private static int partitionHoare(int[] arr, int l, int r) {
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int pivot = arr[l];
int i = l;
int j = r;
while (i < j) {
// 先让j从后向前扫描到第一个 < v的元素停止
while (i < j && arr[j] >= pivot) {
j --;
}
arr[i] = arr[j];
// 再让i从前向后扫描到第一个 > v的元素停止
while (i < j && arr[i] <= pivot) {
i ++;
}
arr[j] = arr[i];
}
arr[i] = pivot;
return i;
}


## 三、算法分析



> 
> 快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现来。
> 
> 
> 


**时间复杂度： O（nlogn）**


* n：每次分区函数的数组扫描
* logn：递归次数，”递归树“的高度


**空间复杂度：递归调用次数 O（logn）**


**如图所示：递归调用次数平均情况下就是一个二叉树的高度logn**


![在这里插入图片描述](https://img-blog.csdnimg.cn/122e821df449470585432aa002dac12b.png)


**数组扫描O（n）**


![在这里插入图片描述](https://img-blog.csdnimg.cn/733f37a634c149d7b538fe05c75f04d9.png)  
 所以时间复杂度是O（nlogn），空间复杂度是O（logn）


## 四、注意事项


**归并排序**无论数据长啥样子，都是无脑的一分为二，保证递归次数一定是logn级别，非常稳定的nlogn的算法。


而**快速排序**的性能严格受制于初始数据的情况而定。


**近乎有序的数组上，快速排序的性能退化非常的快。**


关于分区点的选择问题：


**极端情况下，数组就是一个完全有序的数组**


此时当数组近乎有序时，按照最左侧元素进行分区的时候，造成左右两颗递归树严重不平衡，甚至**极端情况下退化为链表**


空间：O（ 
 
 
 
 
 l 
 
 
 o 
 
 
 g 
 
 
 n 
 
 
 
 logn 
 
 
 logn） -> O( 
 
 
 
 
 n 
 
 


![img](https://img-blog.csdnimg.cn/img_convert/209466dae49e4f0085702c8ecb078fac.png)
![img](https://img-blog.csdnimg.cn/img_convert/3bd18347dfdd2add5b42def2b481c5f1.png)
![img](https://img-blog.csdnimg.cn/img_convert/e70f81a2ede665765b04994e980c7652.png)

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

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

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

片转存中...(img-8yiTFXTo-1715660024819)]
[外链图片转存中...(img-lkJwpkW8-1715660024820)]
[外链图片转存中...(img-DtjjAtWq-1715660024820)]

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

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

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