排序3_快排

最新推荐文章于 2023-08-09 11:42:00 发布
最新推荐文章于 2023-08-09 11:42:00 发布
阅读量266 收藏
点赞数
分类专栏： Java数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43361209/article/details/102308906
版权

文章目录

快排(不稳定)

1.递归

原理：

  1. 从待排序区间选择一个数，作为基准值(pivot)；
    (基准值在最左侧，先从右向左找；基准值在最右侧，先从左向右找)
  2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
  3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1， 代表已经有序，或者小区间的长度 == 0，代表没有数据。
    public static void quickSort(int[] array) { //当前形参不适合递归
        quickSortInter(array, 0, array.length - 1);
         //用quickSortInter实现递归 （数组，左下标，右下标）
    }
    
    // [left, right]
    private static void quickSortInter(int[] a, int left, int right) {
        if (left >= right) { //递归出口
            // 直到 长度 <= 1
            return;
        }
        // 1. 选择基准值 array[left]
        // 2. 做 partition
        int pivotIndex = partition(a, left, right);
        // 左边小区间 [left, pivotIndex - 1]
        // 右边小区间 [pivotIndex + 1, right]
        // 3. 分别对左右小区间按同样方式处理
        quickSortInter(a, left, pivotIndex - 1);
        quickSortInter(a, pivotIndex + 1, right);
    }

1.1 hoare法—partition（常用）

在这里插入图片描述

private static int partition1(int[] a, int left, int right) {
        int begin = left;
        int end = right;
        int pivot = a[left];
        // [left, begin)        <= pivot
        // (end, right]         >= pivot
        while (begin < end) {
            while (begin < end && a[end] >= pivot) {
                end--;
            }
            while (begin < end && a[begin] <= pivot) {
                begin++;
            }
            swap(a, begin, end);
        }
        swap(a, left, begin);
        return begin;
    }

1.2 挖坑法—partition

基本思路和Hoare 法一致，只是不再进行交换，而是进行赋值（填坑+挖坑）

private static int partition2(int[] a, int left, int right) {
        int begin = left;
        int end = right;
        int pivot = a[left];
        // [left, begin)        <= pivot
        // (end, right]         >= pivot
        while (begin < end) {
            while (begin < end && a[end] >= pivot) {
                end--;
            }
            a[begin] = a[end];

            while (begin < end && a[begin] <= pivot) {
                begin++;
            }
            a[end] = a[begin];
        }
        a[begin] = pivot;
        return begin;
    }

1.3 前后遍历法—partition

 private static int partition3(int[] a, int left, int right) {
        // pivot = array[left]
        // 比较区间 [left + 1, right]
        int pivot = a[left];
        int d = left + 1;
        //[left,d)  <=pivot
        //[d,i)     >=pivot
        for (int i = left + 1; i <= right; i++) {
            if (a[i] < pivot) {
                swap(a, i, d++);
            }
        }

        swap(a, d - 1, left);
        return d - 1;
    }

1.4 快排注意事项

1）partition不是快排，只是快排的一个步骤。
2）partition一定要所有的数据都和基准值作比较。
      eg：基准值在左,先走右边；基准值在右,先走左边
3）partition时间复杂度O(n)，空间复杂度O(1)。
4）快排时间复杂度 （遍历*递归深度）: O(n)*O(log(n))~O(n^2)
在这里插入图片描述

快排完整代码：递归版

选取最左侧元素为基准值（三种partion）：

public class QuickSort {
    public static void quickSort(int[] array) { 
        // 当前形参不适合递归
        // 用quickSortInter实现递归 （数组，左下标，右下标）
        quickSortInter(array, 0, array.length - 1); 
    }

    // [left, right]
    private static void quickSortInter(int[] a, int left, int right) {
        if (left >= right) {
            // 直到 长度 <= 1
            return;
        }
        // 1. 选择基准值 array[left]
        // 2. 做 partition
        int pivotIndex = partition3(a, left, right);
        // 左边小区间 [left, pivotIndex - 1]
        // 右边小区间 [pivotIndex + 1, right]
        // 3. 分别对左右小区间按同样方式处理
        quickSortInter(a, left, pivotIndex - 1);
        quickSortInter(a, pivotIndex + 1, right);
    }

    private static int partition1(int[] a, int left, int right) {
        int begin = left;
        int end = right;
        int pivot = a[left];
        // [left, begin)        <= pivot
        // (end, right]         >= pivot
        while (begin < end) {
            while (begin < end && a[end] >= pivot) {
                end--;
            }
            while (begin < end && a[begin] <= pivot) {
                begin++;
            }

            swap(a, begin, end);
        }
        swap(a, left, begin);
        return begin;
    }

    private static int partition2(int[] a, int left, int right) {
        int begin = left;
        int end = right;
        int pivot = a[left];
        // [left, begin)        <= pivot
        // (end, right]         >= pivot
        while (begin < end) {
            while (begin < end && a[end] >= pivot) {
                end--;
            }
            a[begin] = a[end];

            while (begin < end && a[begin] <= pivot) {
                begin++;
            }
            a[end] = a[begin];
        }
        a[begin] = pivot;
        return begin;
    }

    private static int partition3(int[] a, int left, int right) {
        // array[left]
        // [left + 1, right]
        int pivot = a[left];
        int d = left + 1;
        for (int i = left + 1; i <= right; i++) {
            if (a[i] < pivot) {
                swap(a, i, d++);
            }
        }

        swap(a, d - 1, left);
        return d - 1;
    }

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

选取最右侧元素为基准值，采取hoare法做partion示例：

public class TestSort {
    public static void quickSort(int[] array){
        // []
        quickSortHelp(array,0,array.length-1);
    }

    private static void quickSortHelp(int[] array, int left, int right) {
        if(left >= right){
            // 区间中有 0 个元素或者 1 个元素. 此时不需要排序
            return;
        }
        
        // 区间中有 0 个元素或者 1 个元素. 此时不需要排序
        int pivotIndex = partition(array,left,right);
        quickSortHelp(array,left,pivotIndex-1);
        quickSortHelp(array,pivotIndex+1,right);
    }

    private static int partition(int[] array, int left, int right) {
        int baseIndex = right;
        int base = array[right]; //最右侧为基准值
        while (left<right){
            // 从左向右找比基准值大的元素
            while (left<right && array[left] <= base){
                left++;
            }// 当上面循环结束时，
            // left 要么和right重合，要么left指向一个大于base的值

            // 从左向右找比基准值小的元素
            while (left<right && array[right] >= base){ // 此处等号不能省略 不然基准值可能被交换到其他位置
                right--;
            }// 当上面循环结束时，
            // right 要么和left重合，要么right指向一个小于base的值

            swap(array,left,right);
        }

        // 此时 left = right 相遇了,将相遇位置元素和基准值进行交换
        swap(array,left,baseIndex); 
        // 返回此时基准值的下标，即重合位置下标
        return left;
    }

    private static void swap(int[] array, int left, int right) {
        int temp = array[left];
        array[left] = array[right];
        array[right] = temp;
    }

    public static void main(String[] args) {
        int[] array = {6,1,2,7,9,3,4,5,10,8};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}

为什么最后一步将相遇位置元素和基准值进行交换swap(array,left,baseIndex);，仍然能满足快排的要求呢？
答：baseIndex 是这个序列中最后一个元素的下标，要求 left 和 right 重合位置元素必需是 >= 基准值的元素才可以交换。
①left++; 导致和 right 重合。此时最终的值取决于上次循环中 right 指向的值。上次循环中，right应该是找到了一个小于基准值的值，然后和一个大于基准值的值交换了，此处最终的 g 一定是大于基准值的。
②right--;导致和 left 重合。此时最终的值取决于上次循环中 left 指向的值。上面的 left++ 退出一定是 left 找到了比基准值大的元素，此时 left 和 right 重合元素则一定也是大于基准值的。

测试结果：
在这里插入图片描述
性能分析：
在这里插入图片描述
当数组逆序时，取第一个或最后一个元素为基准值，时间复杂度O(n2)，空间复杂度O(n)。
快排的空间复杂度，主要与递归深度有关。

2.非递归

原理：利用栈实现区间的管理。

   import java.util.*;
   
   // 升序
   public static void quickSort(int[] array) {
        // 借助栈, 模拟实现递归的过程
        // stack 用来存放数组下标. 通过下标来表示接下来要处理的区间是什么
        Stack<Integer> stack = new Stack<>();
        // 初始情况下, 先把右侧边界下标入栈, 再把左侧边界下标入栈, 左右边界仍然构成前闭后闭区间
        stack.push(array.length - 1);
        stack.push(0);

        while (!stack.isEmpty()) {
            // 这个取元素的顺序要和push的顺序正好相反
            int left = stack.pop();
            int right = stack.pop();
            if (left >= right) {
                // 区间中只有 1 个或 0 个元素, 不需要整理
                continue;
            }
            // 通过 partition 把区间整理成以基准值为中心, 左侧小于等于基准值, 右侧大于等于基准值的形式
            int pivotIndex = partition(array, left, right);

            // 准备处理下个区间.
            // [index + 1, right] 基准值右侧区间
            stack.push(right);
            stack.push(pivotIndex + 1);

            // [left, index - 1] 基准值左侧区间
            stack.push(pivotIndex - 1);
            stack.push(left);
        }
    }

3.快排优化

3.1优化基准值

快速排序的效率和基准值先取的好坏密切相关。如果基准值是一个接近数组中位数的元素，比较平衡；如果基准值刚好取到最大值（最小值），比较差。

1）选择第一个数作为pivot——只有顺序/逆序才是单支树。
2）随机选择任意数作为pivot——不能消除单支树，但减少了退化成单支树的概率。
3）几数取中（一般三数取中）——消除单支树。

3.2小区间使用插排

当区间比较小时，再去递归效率已经不高了。此时不进行递归，直接进行插入排序。

3.3大区间使用堆排

如果区间比较大时，递归深度也会非常深。当递归深度达到一定程度时，把当前区间的排序使用堆排序进行优化。

IUDN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序三种调整基准值方法(hoare，挖坑，前后指针) 和 实现代码示范
zhaocx111222333的博客
03-03 528
快排优化函数hoare快速排序挖坑法快速排序前后指针法递归实现非递归实现顺序表实现队列实现 三种排序逻辑方法是hoare法,挖坑法,前后指针法. 分别可以用递归方法实现和非递归方法实现. 非递归需要一个储存空间来记录没一个层次的左右区间,可以用动态开辟的顺序表,链表,队列等实现. 优化函数 优化函数的目的是为了让一个尽可能靠近中间的位置作为基准. 因为在快速排序的思路中,排序越有序,时间复杂度越高,为n*n(每一个数字都要做一次基本点) 而最优思路是每次都是二分,时间复杂度O(n)为n *logn; int
顺序表快排
weixin_44502835的博客
08-28 146
#include<iostream> #include<cstdio> #define maxSize 100 using namespace std; typedef struct { int data[maxSize]; int length; }Sqlist; void scan(Sqlist &L,int length)//创建 { for...
快速排序
海淀一只安东尼
03-07 191
基本思路： 数组int[] nums 左边界left 右边界right （三个参数） 找一个基准数，一般以最左边的数作为基准数 base=nums[left] 右索引从右开始往左搜索，找到第一个比基准数小的数，暂停；左索引从左往右搜索第一个比基准数大的数，暂停； 交换两个数的位置； 继续从右往左，从左往右寻找，然后继续交换，直到左右索引相遇，退出； 交换基准数和相遇位置的数，此时基准数左...
使用快排思想 求第n大的值
zhongkeli的专栏
10-18 997
#include "iostream" #include "vector" #include #include using namespace std; template int partition(vector &a,int low,int high){ T temp = a[low]; while(low < high){ while((low temp)) --high;
排序算法——快速排序
心皿月的博客
07-12 924
目录：🚏基本思想:🦼算法描述：🛴实例：思路步骤：具体实现步骤：代码实现：🛹算法性能分析快速排序主要是通过选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边。依次递归，直到整体的序列都有序。对序列 26,53,67,48,57,13,49,32,60,50进行快速排序①选基准，一般选择左边界作为基准②先从后向前，找到比基准小的值时停止，将该high位置的元素放到空位置（low位置）③从前向后找比基准大的值位置停止，将此时low位置元素放到high位置④重复②③步骤...
快排的随机化版本.rar_快排
09-15
快速排序的随机化版本
冒泡排序 快排 堆排序 的c++实现
07-18
C++实现快速排序通常使用递归，选择一个基准值，通过一趟排序将待排记录分隔成独立的两部分，之后对基准值左右两边的子序列分别进行快速排序。快速排序的平均时间复杂度为O(n log n)，但在最坏情况下（已排序或逆序...
Quickly3way.rar_三路快排java
09-23
java 三分切向快排，对于拥有大量重复的数据进行排序能提高效率……
Algorithm_hash归并快排算法_
09-30
标题中的"Algorithm_hash归并快排算法_"表明我们要讨论的是一个与哈希（Hash）合并和快速排序（Quick Sort）算法相关的编程实现。哈希合并通常用于数据处理和排序，而快速排序是一种高效的排序算法，它利用了分治的...
十大排序——3.快速排序
m0_52096593的博客
08-09 252
所以应该先先循环 j，再循环 i。
排序算法——快速排序（Quicksort）基准值的三种选取和优化方法
热门推荐
zou_albert的博客
07-17 3万+
目录1 快速排序的基本原理1.1快速排序的基本思路：2 举例说明总结：3 代码演示4 关于快排的基准值的选取4.1 固定位置选取基准值测试数据：4.2 随机选取基准值测试数据4.3 三数取中法，选取基准元5 四种优化方式优化1：当待排序序列的长度分割到一定大小后，使用插入排序优化2：在一次分割结束后，可以把与Key相等的元素聚在一起，继续下次分割时，不用再对与key相等元素分割。参考链接： 1 快速排序的基本原理 关于快速排序，它的基本思想就是选取一个基准，一趟排序确定两个区间，一个区间全部比基准值小，
【高级排序】之快速排序
JustryDeng
05-11 456
算法评价： 时间复杂度：。 注：快速排序最坏情况下的时间复杂度是，其平均时间复杂度是。 空间复杂度：。 稳定性：不稳定。 适用数据规模量：大规模。 注：快速排序通常是实际排序中的最好的选择，因为它的平均性能非常好。快速排序的平均时间复杂度为， 相比起基本排序(冒泡、插入、选择排序)的要快得多，相比起同样时间复杂度的归并排序，快速排序的 ...
快排之C语言（各种数据的排序）
qq_53269459的博客
02-19 228
关于快排的一些小问题 1.快排是不稳定的,这个不稳定一个表现在其使用的时间是不确定的,最好情况(O(n))和最坏情况(O(n^2))差距太大,我们一般说的O(nlog(n))都是指的是其平均时间 2.快排是不稳定的,这个不稳定表现在如果相同的比较元素,可能顺序不一样,假设我们有这样一个序列,3,3,3,但是这三个3是有区别的,我们标记为3a,3b,3c,快排后的结果不一定就是3a,3b,3c这样的排列,所以在某些特定场合我们要用结构体来使其稳定(<6>的例子就是说明这个问题的) 3.快排的
模拟实现模拟实现快速排序递归和非递归
紫阳战君的博客
04-06 260
快速排序 快速排序是一种二叉树结构交换排序算法，在日常的使用当中较为频繁的使用； 交换的思想就是 ：就是将序列中的两个值值进行比较，然后根据结果交换两个值在序列中的位置，以升序为例，较大值就想序列尾部移动，较小值向序列前部移动； 快排的思想就是：在待排序的元素当中选择一个元素为基准值，按照该排序要求将序列分为两个子序列，左边子序列元素均小于基准值(左右子序列均不包含该基准值)，右边子序列均大于基...
顺序表的快速排序
weixin_38345919的博客
07-31 4784
用c语言建立顺序表，实现快速排序。 这里是用了两个函数实现的，一个分割函数，一个递归。 #include&lt;stdio.h&gt; #define ListSize 20 typedef int DataType; typedef struct{ DataType data[ListSize]; int length; }Seqlist; Seqlist CreateList(Se...
快速排序基准选择及优化
lxk2017的博客
10-28 6264
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 6.1 算法描述 快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下： 从数列中挑出一个元素，称为 “基准”（pivot）； 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准...
快排+堆排序
puyu9714的博客
05-01 153
import java.util.Scanner; public class quickSort { public static void main(String[] args) { int[] nums = new int[]{6,4,32,5,6,7,8,89,0,1}; quickSort(nums); for(int x : nums){ System.out....
尝试用顺序表实现排序算法(持续更新..)
erichhhhho的博客
04-05 1万+
数据结构刚刚学到顺序表，于是顺便试下复习下C语言，自学下后面必会的各种排序算法并自己实现下。（排序算法毕竟比较基础也是很多时候面试会面到的）算是随笔吧,最近又挺忙的，搞项目的事 排序算法很多，按依据的原则分可以有：**- 插入排序 - 交换排序 - 选择排序 - 归并排序 - 计数排序**按时间复杂度分可以有： O(nlogn); O(n^2); O(d*n);1. 插入
堆排 快排 冒泡排序
最新发布
09-19
堆排序是利用堆这种数据结构所设计的一种排序算法。它通过构建一个最大堆（升序排序）或最小堆（降序排序），将堆顶元素与最后一个元素交换，然后调整堆，再次将堆顶元素与倒数第二个元素交换，如此往复，直到排序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值