快速排序、归并排序、数组切分(Partition Array)、Quick Select算法总结

最新推荐文章于 2022-09-03 16:38:56 发布
最新推荐文章于 2022-09-03 16:38:56 发布
阅读量379 收藏
点赞数 1
分类专栏： 算法刷题笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fat_cai_niao/article/details/103745396
版权

文章目录

1. 快速排序

思路

  • 先整体有序，后局部有序
  • 先将整个大数组以某个pivot划分成左右有序的状态，然后缩小区间，重复这个过程
  • 具体的实现细节均在代码中

代码

class LeetCode912 {
    public List<Integer> sortArray(int[] nums) {
        List<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0){
            return result;
        }
        int start = 0;
        int end = nums.length - 1;
        quickSort(nums,start,end);

        for (int num : nums) {
            result.add(num);
        }
        return result;
    }
    //0. 这是个递归函数，它的定义是 在闭区间[start,end]中，把所有小于 nums[(start+end)/2]的数都放在它左边
    //   把所有大于这个的数都放在它右边。然后不断的去缩小这个区间
    //   也就是先整体有序 后局部有序
    private void quickSort(int[] nums, int start, int end) {
        //1. 递归出口
        if (start >= end){
            return;
        }
        //1.1 缓存区间端点 后面缩小区间的时候还需要这两个端点的信息
        int left = start;
        int right = end;

        //2. get value not index
        int pivot = nums[(end + start)/2];
        //2.1 接下来的操作就是以pivot为锚点 切分数组
        //    注意这里的细节 left <= right,为何要等于呢？
        //    就是为了跳出while后，能达到这样的状态:start......right,left,.....end
        while (left <= right){
            //2.2 找到第一个应该在 pivot右边的数
            while (left <= right && nums[left] < pivot ){
                left++;
            }
            //2.3 找到第一个应该在 pivot左边的数
            while (left <= right && nums[right] > pivot){
                right--;
            }
            //2.4 找到后，完成交换
            if (left <= right){
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
        //3. 跳出while，完成了本次区间内的切分，接下来缩小区间
        //3.1 此时left和right的状态一定是  start......right,left,.....end
        quickSort(nums, start, right);
        quickSort(nums, left, end);
    }
}

2. 归并排序

思路

  • 先局部有序，后整体有序
  • 先一直把数组二分下去，直到找到最小有序的部分，那么就开始向上合并两个有序的部分
  • 显然最开始最小的有序部分就是单个数字本身嘛
  • 既然需要合并两个有序的数组，那么肯定就额外需要另一个数组来腾挪，这也是归并相对于快排劣势的一点，需要额外的开辟一个数组的额外空间
  • 细节都在代码里

代码

class LeetCode912 {
    public List<Integer> sortArray(int[] nums) {
        List<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0){
            return result;
        }
        int start = 0;
        int end = nums.length - 1;
        //用于合并两个有序数组
        int[] temp = new int[nums.length];
        mergeSort(nums,start,end,temp);
        for (int num : nums) {
            result.add(num);
        }
        return result;
    }
    //0. 这是一个递归函数，其定义是：将闭区间[start,end]划分为两半
    private void mergeSort(int[] nums, int start, int end, int[] temp) {
        //3.出
        //3.1 当切分到只剩一个元素的时候，就无需再继续往下了，此时已经是最小的有序区间
        if (start >= end){
            return;
        }
        //1.分
        //  就是分治法的味道，先分下去
        int mid = (end - start)/2 + start;
        mergeSort(nums, start, mid, temp);
        mergeSort(nums, mid+1, end, temp);
        //2.合
        //  从上述递归中出来后，可以认为 区间：[start,mid]和[mid+1,end]已经是有序了
        //  那么接下来只需要合并这两个有序区间即可
        merge(nums,start,mid,end,temp);
    }
    //此函数可认为是合并两个有序数组
    private void merge(int[] nums, int start, int mid, int end, int[] temp) {
        //1. 两有序数组的起始点
        int left = start;
        int right = mid +1;
        //2. 有序数组的index
        int index = 0;
        //3. 这里都是index，所以可以取到
        while (left <= mid && right <= end){

            if (nums[left] < nums[right]){
                temp[index++] = nums[left++];
            }else {
                temp[index++] = nums[right++];
            }
        }
        //3.1 double check
        while (left <= mid){
            temp[index++] = nums[left++];
        }
        while (right <= end){
            temp[index++] = nums[right++];
        }

        //4. 现在数组nums中[start,end]都是有序的,但是呢，这一部分的值还暂存在temp的[0,index]区间内
        //4.1 现在要把这个有序的部分赋值给nums的[start,end]部分
        //4.2 要注意这里index不能取等，因为你想，最后一个元素赋值给temp后，index完成了一次自加操作
        for (int i = 0; i < index; i++) {
            nums[start++] = temp[i];
        }
    }
}

3. 数组切分问题(Partition Array)

3.1 LintCode-31. Partition Array

题意

  • 给定数组和一个数k，要求把数组中<k的数放在左边，>=k的数放在右边，返回第一个大于等于k的数的索引

思路

  • 这不就是快排中每一次划分的算法嘛
  • 只要快排理解了，这一道题就很简单了

代码

 public int partitionArray(int[] nums, int k) {
        // write your code here

        if (nums == null || nums.length == 0){
            return 0;
        }

        int left = 0;
        int right = nums.length - 1;
        while (left <= right){

            while (left <= right && nums[left] < k){
                left++;
            }
            while (left <= right && nums[right] >= k){
                right--;
            }

            if (left <= right){
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
            }
        }
        // start ... right left ... end
        return left;
    }

3.2 LintCode373. Partition Array by Odd and Even

题意

  • 给定数组
  • 将数组中的奇数放在前面(左边)
  • 将数组中的偶数放在后面(右边)

思路

  • 和上题完全一样嘛，只是条件变了

代码

 public void partitionArray(int[] nums) {

        if (nums == null || nums.length == 0){
            return;
        }

        int left = 0;
        int right = nums.length - 1;
        while (left <= right){

            //0. 找到第一个应该在 右侧的偶数
            while (left <= right && nums[left] %2 == 1 ){
                left++;
            }
            //1. 找到第一个应该在 左侧的奇数
            while (left <= right && nums[right] % 2 == 0){
                right--;
            }
            //2.交换
            if (left <= right){
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }

    }

3.3 LintCode49.Sort Letters by Case

题意

  • 给定字符数组
  • 把小写字母放在前面
  • 把大写字母放在后面

思路

  • 和上题完全一致，只是判断条件变成了字母是否为大小写

代码

 public void sortLetters(char[] chars) {
        // write your code here

        if (chars == null || chars.length == 0){
            return;
        }
        int left = 0;
        int right = chars.length - 1;
        while (left <= right){
            //0. 找到第一个应该 在右侧的大写字母
            while (left <= right && Character.isLowerCase(chars[left])){
                left++;
            }
            //1. 找到第一个应该 在左侧的小写字母
            while (left <= right && Character.isUpperCase(chars[right])){
                right--;
            }
            if (left <= right){
                char temp = chars[left];
                chars[left] = chars[right];
                chars[right] = temp;
                left++;
                right--;
            }
        }

    }

3.4 LintCode144-Interleaving Positive and Negative Numbers

题意

  • 给定数组
  • 要求将数组划分为正负相间的样式

思路

  • 关键在于处理正负数数量的影响
  • 1.首先把所有的负数放在左边 正数放在右边
  • 2.然后统计数量
  • 3.数量多的代表第一个数和最后一个数都是它
  • 4.然后按照步长为2前后交换即可

代码

 public void rerange(int[] A) {
        // write your code here
        if (A == null || A.length == 0){
            return;
        }
        int left = 0;
        int right = A.length - 1;
        //0. 先把所有的负数放在左侧 正数放在右侧
        while (left <= right){
            while (left <= right && A[left] < 0){
                left++;
            }
            while (left <= right && A[right] > 0){
                right--;
            }
            if (left <= right){
                int t = A[left];
                A[left] = A[right];
                A[right] = t;
                left++;
                right--;
            }
        }

        //1. 统计正负数的数量
        int posNum = 0;
        int negNum = 0;
        for (int num : A) {

            if (num > 0){
                posNum++;
            }
            if (num < 0){
                negNum++;
            }
        }
        //2. 根据正负数数量来决定完成划分后谁位于首位和尾位
        //2.1 数量多的那一方 占据首尾
        //2.2 left和right代表交换的起始位置
        if (posNum > negNum){
            //2.3 那么第一个数和最后一个数都是正数
            left = 0;
            right = A.length - 2;
        }else if (posNum < negNum){
            //2.4 那第一个数和最后一个数都是负数
            left = 1;
            right = A.length -1;
        }else {
            //2.5 一样多,那就按照负正负正的次序进行排列即可
            left = 0;
            right = A.length - 1;
        }
        //3. 随后进行交换，注意步长为2
        while (left <= right){
            int t = A[left];
            A[left] = A[right];
            A[right] = t;
            left+=2;
            right-=2;
        }
    }

4. QuickSelect问题

4.1 LeetCode215. Kth Largest Element in an Array

题意

  • 给定无序数组和一个数k，要求找到改数组中第k大的数

思路

  • 利用数组划分和快速排序思想
  • 不断的缩小第k大可能存在的区间
  • 具体细节都在代码注释中

代码

class LeetCode215 {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0){
            return -1;
        }
        
        return quickSelect(nums,0,nums.length - 1,k);
        
    }
    //0. 思想就在于通过切分数组 不断的压缩 k-th可能在的区间
    private int quickSelect(int[] nums, int start, int end, int k) {
        //2.递归出口
        //2.1 为何相等的时候就要退出了呢，因为此时区间中就只有一个数了嘛，那这个数肯定就是要找的
        if (start == end){
            return nums[start];
        }


        int left = start;
        int right = end;
        int pivot = nums[(left + right)/2];
        //0. 以pivot为界，把数组元素切分为两部分，左侧大于它，右侧小于它
        //0.1 注意这里和快排不同，因为这里是求第k大
        while (left <= right){

            //0.2 找到第一个应该在右边的数
            while (left <= right && nums[left] > pivot){
                left++;
            }
            while (left <= right && nums[right] < pivot){
                right--;
            }
            //0.3 交换
            if (left <= right){
                int t = nums[left];
                nums[left] = nums[right];
                nums[right] = t;
                left++;
                right--;
            }
        }
        //1. 完成划分，现在left和right的位置关系有两种可能
        //1.1 start....right,left....end
        //1.2 start.....right,A,left...end 这种隔了一个的状态是由于上面while中的if导致的
        //1.3 当if中二者 left = right后，满足添加，执行if内的代码，然后会 left++,right--，就会导致这种刚好错开一个的情况
        //1.4 我们要找第k大，那么就需要判断 第k大 可能会落在哪个区间
        //1.5 现在一个好消息在于区间[start，right]中的数都大于区间[left,end]
        //1.6 那么需要判断k是否落在这两个区间内，第k大是基于1的，而上述的left这些都是索引，基于0，所以需要k-1
        if (start + k - 1 <= right){
            //1.7 第k大在左半区间，所以扔掉右边的一半
            return quickSelect(nums, start, right, k);
        }
        if (start + k - 1 >= left){
            //1.8 第k大在右半区间,所以扔掉左边的一半
            //1.8.1 左边一半的数量是多少呢
            return quickSelect(nums,left,end,k - (left - start));
        }
        //1.9 如果落在中间，即情况1.2
        return nums[right+1];
    }
}

4.2 LintCode80. Median

题意

  • 给定未排序数组，求其中位数

思路

  • 只要分析清楚中位数是第几大的数
  • 那么问题就转换为了在无序数组中求第k大的数问题
  • 分奇数和偶数不难分析出中位数都是第n/2 - 1大的数

代码

public class Solution {
  public int median(int[] nums) {

        //0. 简单分析发现，不管数字个数是奇数还是偶数，其中位数都是第(n/2) + 1大的数
        int k = nums.length/2 + 1;
        //1. 那么剩余的工作就是在一个未排序的数组中找第k大的数
        return findKthLargest(nums, k);
    }

    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0){
            return -1;
        }

        return quickSelect(nums,0,nums.length - 1,k);

    }
    //0. 思想就在于通过切分数组 不断的压缩 k-th可能在的区间
    private int quickSelect(int[] nums, int start, int end, int k) {
        //2.递归出口
        //2.1 为何相等的时候就要退出了呢，因为此时区间中就只有一个数了嘛，那这个数肯定就是要找的
        if (start == end){
            return nums[start];
        }


        int left = start;
        int right = end;
        int pivot = nums[(left + right)/2];
        //0. 以pivot为界，把数组元素切分为两部分，左侧大于它，右侧小于它
        //0.1 注意这里和快排不同，因为这里是求第k大
        while (left <= right){

            //0.2 找到第一个应该在右边的数
            while (left <= right && nums[left] > pivot){
                left++;
            }
            while (left <= right && nums[right] < pivot){
                right--;
            }
            //0.3 交换
            if (left <= right){
                int t = nums[left];
                nums[left] = nums[right];
                nums[right] = t;
                left++;
                right--;
            }
        }
        //1. 完成划分，现在left和right的位置关系有两种可能
        //1.1 start....right,left....end
        //1.2 start.....right,A,left...end 这种隔了一个的状态是由于上面while中的if导致的
        //1.3 当if中二者 left = right后，满足添加，执行if内的代码，然后会 left++,right--，就会导致这种刚好错开一个的情况
        //1.4 我们要找第k大，那么就需要判断 第k大 可能会落在哪个区间
        //1.5 现在一个好消息在于区间[start，right]中的数都大于区间[left,end]
        //1.6 那么需要判断k是否落在这两个区间内，第k大是基于1的，而上述的left这些都是索引，基于0，所以需要k-1
        if (start + k - 1 <= right){
            //1.7 第k大在左半区间，所以扔掉右边的一半
            return quickSelect(nums, start, right, k);
        }
        if (start + k - 1 >= left){
            //1.8 第k大在右半区间,所以扔掉左边的一半
            //1.8.1 左边一半的数量是多少呢
            return quickSelect(nums,left,end,k - (left - start));
        }
        //1.9 如果落在中间，即情况1.2
        return nums[right+1];
    }
}
小胖头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序分割点的2种方式
nsjlive的博客
03-06 1386
快速排序是一种交换排序。 基本思想： 通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 参考：https://www.jianshu.com/p/5f38dd54b11f 找分割点的核心代码： 赋值法：（参考百度百科：快速排序 ） ...
七种常见的VB排序算法示例程序
01-11
七种常见的VB排序算法示例程序 包含常见的几种算法,只不过用VB来实现
排序---快速排序及其切分函数Partition应用
weixin_30567225的博客
06-28 175
快速排序   快速排序通过一个切分元素将数组分成两个子数组，左子数组小于等于切分元素，右子数组大于切分元素，将这两个子数组排序，也就是将整个数组排序了。 代码如下： public class Sort{ public static void quickSort(int []arr){ if(arr=null||arr.length<2) ret...
八大排序(下)
qq_62939852的博客
09-03 675
所以我们先判断下是否符合区间值>1的条件，如果符合，则先将右边的右入栈，再入右边的左 ，其次入左边的右，再入，做左边的左。2.再从左边找比key大的数，找到后将值传给左边pivot所在位置 ，同时pivot指向左边。当左区间的数不够gap所分的数，右区间不存在时，若将左区间拷贝回去会出现随机值。则gap为1时就将 左边区间个数为1 与右边区间个数为1 进行排序。gap为2时就将 左边区间个数为2 与右边区间个数为2 进行排序。gap为4时就将 左边区间个数为4 与右边区间个数为4 进行排序。
VB实现6大排序算法---动态过程展示（建议收藏）
「 刘一哥与GIS的故事」
06-25 2968
VB实现6大排序算法：插入排序、基数排序、快速排序、希尔排序、选择排序、归并排序。可以随机生成指定个数的数据，显示排序过程，给出排序结果，计算排序算法消耗的时间。 生成随机数： 排序结果： 插入排序： 选择排序： 归并排序： 快速排序： 希尔排序： 基数排序： 核心代码 VERSION 1.0 CLASS BEGIN MultiUse = -1 'True Persistable = 0 'NotPersistable DataBindingBehavior = 0 '.
快速排序算法 C语言.md
最新发布
06-24
快速排序是一种高效的排序算法，使用分治法策略来把一个序列分为较小和较大的两个子序列，然后递归地排序两个子序列。 代码首先定义了swap函数，用于交换两个整数的值。quickSort是快速排序的递归函数，它调用...
Java实现快速排序算法（源代码）
05-07
在Java实现中，快速排序算法通过quickSort方法接收待排序数组和左右索引作为参数，递归地调用partition方法进行数据划分，并分别对划分后的子序列进行排序。partition方法选择数组中的一个元素作为基准，通过比较和...
go-基于Golang实现的快速排序算法.zip
03-09
快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它采用了分治（Divide and Conquer）的思想，将一个大问题分解成两个或更多的小问题来解决。在Golang中实现快速排序，我们可以充分利用...
C语言实现快速排序算法（含实现步骤）
12-21
快速排序的平均时间复杂度为O(n log n)，在最坏的情况下（输入数组已经排序或逆序）时间复杂度为O(n^2)，但在实际应用中，由于其优秀的平均性能和原地排序特性，快速排序仍然是广泛使用的排序算法之一。
排序问题(选择法排序, 冒泡法排序, 合并法排序),VB6.0源代码编写
06-10
排序问题(选择法排序, 冒泡法排序, 合并法排序),VB6.0源代码编写
vb 简单快速排序
01-10
vb.net 语言 开发的简单快速排序，里面附带工程文件，打开便可以运行，附带截图！用Visual Studio 2010 以上版本打开
基本算法-partition函数
zhouyufei0001的博客
09-15 1488
partition函数为实现快速排序算法的关键函数，其作用是给定一个数组arr[]和数组中任意一个元素a，重排数组使得a左边都小于它，右边都不小于它。 public class Partition { public static int partition(int[] arr,int start,int end,int desIndex){ int des=arr[desIndex
排序之四-----归并排序（合并排序）
qqqil的专栏
07-31 389
void mergeSort(int a[],int s,int r){ if(r >s){ int mid = (s+r)/2; mergeSort(a,s,mid); mergeSort(a,mid+1,r); int p=s,q =mid+1; int tmp=p; int b[r-s+1]; for(int i=0;i<r+1-s;i++){ if(p>
归并排序算法的时间复杂度
crookshanks_的博客
07-10 1万+
来自教程：https://time.geekbang.org/column/article/41913 我们对n个元素进行归并排序，需要时间T(n)， 那分解成两个子数组排序的时间都是T(n/2)。 merge()函数合并的时间复杂度是O(n)。 归并排序的时间复杂度计算公式是： T(1) = C； n=1 时，只需要常量级的执行时间，所以表示为 C。 T(n) = 2*T(n/2...
合并排序(归并排序)
Empirefree的博客
09-25 1万+
归并排序
C语言实现----快速排序
热门推荐
zhourunan
07-15 4万+
1.快速排序是一种交换排序 2.基本思想：         选取一个基准数；         然后将大于和小于基准的元素分别放置于基准数两边；         继续分别对按此方法分治基准数的两侧，直至整个序列有序。 3. 注意问题         基准数的选择（通常选取头元素或者尾元素）         元素的查找（一组一组的查找需要交换的元素）         递归调用（终止递归...
Java 归并排序(基于数组)
01-17 348
    归并排序：归并算法的中心是归并两个已经有序的数组，并且递归调用归并操作。    优点和缺点：比简单排序在速度上快很多；归并排序会占用双倍的存储空间。    效率：归并排序的时间复杂度是 O(N*LogN)；简单排序的复杂度是O(N2)。    每一趟归并的时间复杂度为 O(n), 需要O(logn)次归并 class MergerSort { // 归并排序算法 public v...
归并排序之拆分详解
鸭梨的博客
05-29 679
核心思想 如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。 归并排序使用的就是分治思想。分治，顾名思义，就是分而治之，将一个大问题分解成小的子问题来解决。小的子问题解决了，大问题也就解决了。 从我刚才的描述，你有没有感觉到，分治思想跟我们前面讲的递归思想很像。是的，分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧，这两者并不冲突。 前面我通过举例让你对归并有了一个感性的认识，又告诉你，归并
归并排序（数组）
SE_and_CS
04-11 781
数组的归并排序。 void merge(int vec[], int lo, int mid, int hi); void mergeSort(int vec[], int lo, int hi) { if(hi - lo < 2) return; int mid = (lo + hi) >> 1; mergeSort(vec, lo, mid); mergeSort(vec, mid
Java快速排序算法详解与优化
快速排序是一种广泛使用的排序算法，尤其在编程领域中，它以其高效的性能和相对简单的实现而备受青睐。这种算法由英国计算机科学家C.A.R. Hoare在1960年提出，是基于分治策略的典型应用。 快速排序的核心思想是通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值