归并排序，快排变形应用

已于 2022-08-11 14:58:00 修改
阅读量138 收藏
点赞数 1
文章标签： 算法 排序算法 数据结构
于 2022-08-10 17:37:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smznbhh/article/details/126228368
版权

文章目录

前言

O(NlogN)的排序

一、数组中点防溢出

在取一个数组的中点时，传统写法为：

  • mid=(min+max)/2; 这样会发生（mn+max）溢出。
  • min+(max-min)/2; 可以改成这样。
  • mn+（(max-min)>>1）;也可以这样。

二、master公式

1.master公式的使用

T（N）=a*T（N/b）+O(N^d)
其中T（N）表示母问题规模，a表示子问题调用次数，T（N/b）表示子问题规模，O（N^d）表示其它规模。
必须在子问题规模一样的情况下
时间复杂度

  • logb^a<d —>O(N ^ d)
  • logb^a>d —> O(N ^logb ^a)
  • logb^a==d —> O(N ^d *logN)

归并排序

1.流程

将数组沿中点分成两部分,分别将左右两部分先排序，然后申请辅助空间，依次比较 左右两边的数，根据规则将较大或较小数copy到辅助空间，将这一侧往后移一位和另一侧不移动的数比较，以此类推，最终一边越界将另一边剩下的直接copy进辅助空间，就得到了有序数组。

T（N）=2T（N/2）+O（N）
归并排序的时间复杂度为：O（NlogN）
额外空间复杂度为：O（N）
代码如下

public class mergeSort {
    public static void process(int []arr,int L,int R){ // 递归
        if (L==R){
            return;
        }
        int mid=L+((R-L)>>1);// 取中点
        // 两次递归
        process(arr,L,mid);
        process(arr,mid+1,R);
        merge(arr,L,mid,R);
    }
    public static void merge(int []arr,int L,int M,int R){// 比较
        int[] help=new int[R-L+1];// 辅助空间
        int i=0;
        int p1=L; // 左指针
        int p2=M+1; // 右指针
        // O（N）
        while (p1 <= M && p2 <= R){// 比较
           help[i++]= arr[p1]<=arr[p2]?arr[p1++]: arr[p2++];
        }
        // 最终
        while (p1<=M){
            help[i++]=arr[p1++];
        }
        while (p2<=R){
            help[i++]=arr[p2++];
        }
        // O（N）
        for (int j=0;j<help.length;j++){
            arr[L+j]=help[j];
        }
    }
}

2.归并排序拓展

（1）求小和问题

描述：在一个数组中，每一个数左边比当前的数大累加起来，叫做这个数组的小和。求一个数组的小和。
例如：
[1,3,4,2,5],1左边比1小的数，没有；3左边比3小的数，1；4左边比4小的数，1、3；2左边比2小的数，1；5左边比5小的数，1、3、4、2；所以小和为1+1+3+1+1+3+4+2=16。

思路：转换问题，将求左边比当前数小改为求右边比当前数大的个数，再与该数相乘，最后相加得到小和。
例如：
1右边比1大的数有4个，就是14；3右边比3大的有2个，就是32；4右边比4大的有1个，就是41；2右边比2大的有1个，就是21；5右边没有比5大的数；所以小和为14+32+41+21=16。

利用归并找到小和，在左右两边都排序后，只要左边比右边的小，就要进行小和的累加，当相同时，先复制右边的，这样能更快找完但个数的小和。

public class smallSumProblem {
    public static int process(int []arr, int L, int R){ // 递归
        if (L==R){
            return 0;
        }
        int mid=L+((R-L)>>1);
        return process(arr,L,mid) +process(arr,mid+1,R)+merge(arr,L,mid,R); //总小和
    }
    public static int merge(int []arr,int L,int M,int R){// 比较
        int[] help=new int[R-L+1];// 辅助空间
        int i=0;
        int p1=L; // 左指针
        int p2=M+1; // 右指针
        int res =0;
        while (p1 <= M && p2 <= R){// 比较 求小和
            res+=arr[p1]<arr[p2]?(R-p2+1)*arr[p1]:0; // 左边小于右边时，计算小和数
            help[i++]= arr[p1]<arr[p2]?arr[p1++]: arr[p2++];// 左右两边相等时先拷贝右边的
        }
        // 最终
        while (p1<=M){
            help[i++]=arr[p1++];
        }
        while (p2<=R){
            help[i++]=arr[p2++];
        }
        for (int j=0;j<help.length;j++){
            arr[L+j]=help[j];
        }
        return res;
    }
}

结果：
在这里插入图片描述

（2）逆序对问题

描述：在一个数组中，左边的数如果比右边大，则这两个数构成一个逆序对，请打印所有逆序对。

public class reversePairProblem {
    public static void main(String[] args) {
        int[] arr = {5, 3, 4, 2, 1};
        process(arr, 0, 4);
    }

    public static void process(int[] arr, int L, int R) { // 递归
        if (L == R) {
            return;
        }
        int mid = L + ((R - L) >> 1);
         process(arr, L, mid);
         process(arr, mid + 1, R);
         merge(arr,L,mid,R);
    }
    public static void merge(int[] arr, int L, int M, int R) {// 比较
        int p1 = L; // 左指针
        int p2 = M + 1; // 右指针
        while (p1 <= M && p2 <= R) {// 比较
            if (arr[p1]>arr[p2]){
                System.out.println("["+arr[p1]+","+arr[p2]+"]");
                p1++;
            }else {
                p2++;
            }

        }
    }
}

结果：
在这里插入图片描述

3.荷兰国旗问题

（1）荷兰国旗问题一

描述：
给定一个数组arr，和一个数num，请把小于等于num的数放在数组左边，大于num的数放在数组的右边，要求额外空间复杂度O(1)，时间复杂度O（N）。

思路：
他并不要求有序，值啊要将小于等于num的数放左边，大于num的数放右边就可以。先规定一个小于等于num的区域area，area起始是arr第一个数的左边，让指针i指向arr第一个数，让arr[i]与num比较，如果比num小或等，就让i+1，让area往右边扩一位，将arr[i]包含其中；如果arr[i]大于num时，i+1,area不变，接着比较下一位，知道有一位比num小时，交换这一位和area下一位数的位置，再将area往下扩一位，以此类推。

public class dutchFlagQuestionOne {
    public static void main(String[] args) {
        int []arr={3,8,5,3,8,1,2,9,7};
        int num=5;
        hollandOne(arr,num);
        System.out.println(Arrays.toString(arr));
    }
    public static void hollandOne(int []arr,int num){
        if (arr==null||arr.length<2){
            return;
        }
        partition(arr,num,0, arr.length-1);
    }
    public static void partition(int []arr,int num,int L,int R){
        int less=L-1;
        int more=R+1;
        while (L<more){
            if (arr[L]<=num){
                swap(arr,++less,L++);
            }else {
                swap(arr,--more,L);
            }
        }
    }
    //交换方法
    public static void swap(int []arr,int L,int R){
        int temp=arr[L];
        arr[L]=arr[R];
        arr[R]=temp;
    }
}

结果：
在这里插入图片描述

（2）荷兰国旗问题二

描述：
给定一个数组arr，和一个数num，请把小于num的数放在数组左边，等于num的数放在数组中间，大于num的数放在数组的右边，要求额外空间复杂度O(1)，时间复杂度O（N）。

思路:
和上一个差不多，只不过多了一个等于的区域

  • [i]<num,[i]和小于区下一位交换，小于区右扩一位，i++
  • [i]=num，i++
  • [i]>num,[i]和大于区前一位交换，大于区左扩一位，i不变
public class dutchFlagQuestionOne {
    public static void main(String[] args) {
        int []arr={3,8,5,3,8,1,2,9,7};
        int num=5;
        hollandOne(arr,num);
        System.out.println(Arrays.toString(arr));
    }
    public static void hollandOne(int []arr,int num){
        if (arr==null||arr.length<2){
            return;
        }
        partition(arr,num,0, arr.length-1);
    }
    public static void partition(int []arr,int num,int L,int R){
        int less=L-1;
        int more=R+1;
        while (L<more){
            if (arr[L]<=num){
                swap(arr,++less,L++);
            }else {
                swap(arr,--more,L);
            }
        }
    }
    //交换方法
    public static void swap(int []arr,int L,int R){
        int temp=arr[L];
        arr[L]=arr[R];
        arr[R]=temp;
    }
}

结果：
在这里插入图片描述

4.快排

（1）快排1（荷兰国旗问题一的递归）

将最后一个数作为划分数进行判断，先判断第一个数与划分数的大小关系，如果小于等于划分数，与小于区后一位交换，小于区域右扩一位；如果大于划分数，与大于区前一位数交换，大于区左扩一位，返回小于区与大于区的交界值，进行递归，最终必定能得到一个有序数组。
时间复杂度为：O（N^2）
空间复杂度为：O（logN）

public class quickRowOne {
    public static void main(String[] args) {
        int []arr={1,9,4,4,2,5};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int []arr){
        if (arr==null||arr.length<2){
            return;
        }
        quickSort(arr,0,arr.length-1);
    }
    public static void quickSort(int[]arr,int L,int R){
        if (L<R){
            int p=partition(arr,L,R);
            quickSort(arr,0,p-1);
            quickSort(arr,p,R);
        }
    }
    public static int partition(int []arr,int L,int R){
        int less=L-1; // 小于等于区右边界
        int more=R;// 大于区左边界
       while (L<more){
           if (arr[L]<=arr[R]){
               swap(arr,++less,L++);
           }else swap(arr,--more,L);
       }
        swap(arr,more,R);
       return more;
    }
    public static void swap(int []arr,int L,int R){
        int temp=arr[L];
        arr[L]=arr[R];
        arr[R]=temp;
    }
}

结果：
在这里插入图片描述

（2）快排2（荷兰国旗问题二的递归）

在一的基础上添加了=的区域，也就是说=区域的那部分在后面就不用递归排序了。
时间复杂度为：O（N^2）
空间复杂度为：O（logN）

public class quicksortTwo {
    public static void main(String[] args) {
        int []arr={1,9,4,4,2,5};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int []arr){
        if (arr==null||arr.length<2){
            return;
        }
        quickSort(arr,0,arr.length-1);
    }
    public static void quickSort(int[]arr,int L,int R){
        if (L<R){
            int p[]=partition(arr,L,R);
            quickSort(arr,0,p[0]-1);
            quickSort(arr,p[1]+1,R);
        }
    }
    public static int[] partition(int []arr,int L,int R){
        int less=L-1; // 小于等于区右边界
        int more=R;// 大于区左边界
        while (L<more){
            if (arr[L]<arr[R]){
                swap(arr,++less,L++);
            }else if (arr[L]>arr[R]){
                swap(arr,--more,L);
            }else L++;
        }
        swap(arr,more,R);
        return new int[]{less+1,more};
    }
    public static void swap(int []arr,int L,int R){
        int temp=arr[L];
        arr[L]=arr[R];
        arr[R]=temp;
    }
}

结果：
在这里插入图片描述

（3）快排3（随机选取数来划分）

选取划分数时，在列表中随机选取一个数，并人为的将其放到列表的最后一位。
时间复杂度为：O（N*logN）
空间复杂度为：O（logN）

public class quickRowThree {
    public static void main(String[] args) {
        int []arr={1,9,4,2,5};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[]arr){
       if (arr==null||arr.length<2){
           return;
       }
       quickSort(arr,0,arr.length-1);
    }

    // 递归排序
    public static void quickSort(int[]arr,int L,int R){
        if (L<R){
            swap(arr,L+(int)(Math.random()*(R-L+1)),R); // 随机范围数，手动交换到最后一位
            int[]p=partition(arr,L,R);// 用来确定等于区域边界
            quickSort(arr,L,p[0]-1);// 小于区域
            quickSort(arr,p[1]+1,R);// 大于区域
        }
    }

    public static int[] partition(int[]arr, int L, int R){
        int less=L-1; // 小于取右边界
        int more=R;// 大于区左边界
        while (L<more){
            // [i]<num,[i]和小于区下一位交换，小于区右扩一位，i++
            // [i]=num，i++
            // [i]>num,[i]和大于区前一位交换，大于区左扩一位，i不变
            if (arr[L]<arr[R]){
                swap(arr,++less,L++);
            }else if (arr[L]>arr[R]){
                swap(arr,--more,L);
            }else {
                L++;
            }
        }
        swap(arr,more,R);
        return new int[]{less+1,more};
    }
    public static void swap(int[]arr,int L,int R){
        int temp=arr[L];
        arr[L]=arr[R];
        arr[R]=temp;
    }
}

结果：
在这里插入图片描述

总结

上文主要讲了master公式的使用，归并排序以及快排逻辑，以及递归解决问题。

天将降大任于我
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
快排变形 码蹄集
日常学习记录
05-20 295
码蹄集---快排变形
786. 第k个数 【快速排序】
午夜的行人
08-11 584
题目 给定一个长度为 n 的整数数列，以及一个整数 k，请用快速选择算法求出数列从小到大排序后的第 k 个数。 输入格式 第一行包含两个整数 n 和 k。 第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整数数列。 输出格式 输出一个整数，表示数列的第 k 小数。 数据范围 1≤n≤100000, 1≤k≤n 输入样例： 5 3 2 4 1 5 3 输出样例： 3 题解 快速选择 #include <iostream> using namespace std; const int
快速排序详解及应用
weixin_52055811的博客
04-03 825
首先我们要知道的是所有递归的算法，你甭管它是干什么的，本质上都是在遍历一棵（递归）树，然后在节点（前中后序位置）上执行代码，你要写递归算法，本质上就是要告诉每个节点需要做什么。return;} // 对 nums[low..high] 进行切分 // 使得 nums[low..p-1]
快排的应用
q_all_is_well的博客
05-21 455
前几天总结了一下几种常用的排序算法，而且，在比较排序算法的结尾有一个小tips：堆排序和归并排序都是渐进最有的比较排序算法。今天在回顾算法导论的过程中发现，堆排序，快排，归并排序的应用很广泛，重要的不是这种排序的方式，而是这种排序的思想值得我们学习。以快排为例，这种算法思想是可以展开的。以我当前遇到的题目来看，有1.荷兰国旗问题：荷兰国旗有三横条块构成，自上到下的三条块颜色依次为红、白、蓝。现有若...
快速排序应用
loong_的博客
04-20 854
文章目录一、一维数组快速排序解决思路实现二、单链表快速排序解决思路实现三、应用快速排序找前两大的数解决思路实现四、应用快速排序查找第k小的数解决思路实现 一、一维数组快速排序 解决思路 主要需要实现两个函数： 划分函数： 对一维数组进行划分，使得划分结束后，返回下标左边的数都小于该位置的数，右边的都大于该数。 先拿出下标为0位置的数标记为 tmp，再定义两个下标 i 和 j ，分别从数组的两端向中间查找。 当 j 位置的数 > tmp，j 向 左移动一位，直到 j 位置的数 < tmp，将
归并排序归并排序归并排序
最新发布
12-22
归并排序
归并排序Java_归并排序_
10-04
归并排序是一种高效的排序算法，基于分治策略。在Java中实现归并排序，我们可以创建一个名为`MergeSort`的类来封装整个过程。归并排序的基本思想是将待排序的序列分成两个或更多的子序列，对每个子序列分别进行排序...
快排归并qsortsort排序时间比较
08-10
快排归并qsortsort排序时间比较。
归并排序_归并排序_
10-01
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案&quot...
C语言分治法实现归并排序
12-31
本文实例为大家分享了C语言实现归并排序的具体代码，供大家参考，具体内容如下 归并排序的基本思想： 将两个及其以上的有序表合并为一张有序表，把待排序序列通过分治法分为若干个有序子序列，然后每两个子序列合并...
leetcode 剑指offer 45 题
sinat_41479651的博客
03-16 95
leetcode 题 使用快排实现组合数最小
快速排序的三种实现以及应用场景
热门推荐
weizhengbo的博客
08-27 1万+
好了，废话不多说，直接上干货。 1、快速排序的概念： 快速排序(Quicksort)是对冒泡排序的一种改进。 快速排序由C. A. R. Horno在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 2快速排序
快排 (模板及应用)
沐白白的博客
02-13 331
排序 快排 分治 选取分界点 q[l] q[r] q[l+r>>1] 随机选值 调整范围, 递归左右两边 平均复杂度: nlogn 实现思想 选取分界点,有四个典例,然后以分界点调整左右区间,有双指针 i = l-1 , j = r+1 如果满足q[i]<x则i++ ,如果q[j] >x则j-- ,如果停住则交换两数 , 先整体进行一次排序后,然后递归排序每一个区间; 算法模板 #include <iostream> using namespac
【每日算法】快速排序及其应用
jiange_zh的博客
02-18 6761
快速排序快排的最坏运行时间为O（n^2），平均运行时间为O(n logn)，且隐含的常数因子很小，能够进行就地排序。快排基于分治模式，其基本思想：分解：从序列中取出一个数作为基准数，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边，从而得到两个子序列。解决：递归调用快速排序，对两个子序列进行排序。合并：因为子序列是就地排序的，所以合并不需要任何操作。伪代码：quickSort(arr,
快速排序及其应用
木心算法
12-20 1941
快速排序被称为是20世纪10大算法之一，可见其重要性，不明觉厉。 学习快速排序不单单只是一种排序算法，更重要的是其中包含的思想，分治思想。 下面进入正题，本文将给出多种快速排序的方法，并给予评价。 快速排序的思想是分治，分而治之，和归并排序一样，我们将大问题分解同小规模的具有相同解法的小问题。 快速排序的重点在分，归并侧重“并”，所谓分，指的是找到一个位置，这个位置的数将序列划分成两部分，左边比它...
归并排序算法（C语言版本）
ChanCherry的博客
03-23 4837
基本思想 归并排序（Merge Sort）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分成一些小的问题然后进行递归求解，而治的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之）。 实现过程 分而治之 归并排序将待排序数组分成两个各含n/2个元素的子序列，然后对这个两个子序列进行递归排序，最后将这两个已排序的子序列进行合并，即得...
快速排序算法及其应用
su_fei_ma_su的博客
02-20 802
常见的排序算法 冒泡排序，简单排序，插入排序等算法时间复杂度为 n^2，在某些场景下如已知有序的数组中进行排序，调用这些算法可以有效地完成排序功能。 其源码如下： /************************************************ * title : 交换 * 算法复杂度 : ************************************************/ void swap(SqList *L,int i,int j) { int temp
数据结构与算法之美 | 你知道快速排序，那你知道它的衍生应用吗？Partition函数
迈微AI研习社 · 号主
04-09 843
快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小小的程序方面的考试如软考，考研中也常常出现快速排序的身影。 今天我们就来深入挖掘快排中Partition函数的应用！...
归并排序（c语言）
m0_64206188的博客
11-03 1003
归并算法（merge sorting）是一种基于分治思想的排序算法，将数据细分为小块处理，再将排序后的小块合并成为排序大块，从而达到排序功能。
比较选择排序与归并排序：算法详解与应用
归并排序则是分治策略的典型应用，将数组分为两半，分别排序后再合并。它的效率更高，一般采用递归的方式，将大问题分解为小问题，直至子问题规模足够小可以直接解决。归并排序具有稳定的特性，即相等的元素排序后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天将降大任于我

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值