算法|4.归并排序及应用

已于 2023-05-31 21:29:01 修改
阅读量831 收藏
点赞数 1
分类专栏： 算法 文章标签： 算法 排序算法 数据结构 java
于 2023-05-26 18:59:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moteandsunlight/article/details/130892545
版权
本文介绍了归并排序的递归和非递归实现，包括预处理、核心代码和优化点。同时，通过小和问题、逆序对个数和大于其2倍右侧数的个数三个应用实例，展示了归并排序在解决这些问题上的效率和方法。文章还讨论了算法的时间复杂度和空间复杂度，并给出了改写方法和例题总结。
摘要由CSDN通过智能技术生成

算法|4.归并排序及应用

1.归并排序算法

题意：归并排序的递归和非递归实现

解题思路：

​ 递归实现：

  • 预处理：数组为空或者长度小于2的直接返回
  • 调用子过程
  • 子过程终止条件L==R
  • 分解成[L,mid]，[mid+1,R] ，子数组有序，合并子问题的解，全数组有序
  • 合并使用的是双指针法，最终需要将辅助数组的值再还给原数组。

​ 非递归实现：

  • 注意：**当N非常接近整数最大值时，*必须加那一句if(mergeSize>N/2){ break;}不然2之后可能滚成一个负数，但是加了只是保证循环能够停止，结果可能最后一部分右组没有归并完成，但是不加很可能死循环。
  • 主要解决的就是拆分过程：两种办法①模拟栈Stack②自底向上有序
  • 这里主要使用第二种，模拟栈的话需要压入的参数就是左右的坐标，可以封装一个成类，针对对象操作，暂无需要，略。
  • 还是先预处理：处理特殊情况
  • 这里引入了步长的概念，多少步长为1组，然后组内有序（直接拷贝到原数组，不再需要辅助数组）
  • 之后不断扩大步长，然后使用merge合并，直至全数组有序

优化的点：

  • 这里主要是非递归实现的版本
  • 这里合并使用的是左组和右组——我们每次需要指定左组下标和右组下标
  • 控制左指针的边界条件:L<N
  • 控制中间指针边界条件（左组存在）：mergeSize+L-1，M<N（不满足就是左组不够或者右组没了,不满足直接不做合并）
  • 控制右指针的边界条件(右组存在)：R=M+mergeSize-1,右组只要有够不够都需要做合并，只不过R的值需要重新赋值判断一下去边界值和当前计算的最小值
  • 每次重置步长之后，L的起始位置都是0

核心代码：

​ 递归实现：

//递归实现
public static void mergeSort1(int[] arr){
    if(arr==null||arr.length<2){
        return ;
    }
    process(arr,0,arr.length-1);
}

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

private static void merge(int[] arr, int L, int M, int R) {
    int[] help=new int[R-L+1];
    int index=0;
    int p1=L;
    int p2=M+1;
    while(p1<=M&&p2<=R){
        help[index++]=arr[p1]<=arr[p2]?arr[p1++]:arr[p2++];
    }
    while(p1<=M){
        help[index++]=arr[p1++];
    }
    while(p2<=R){
        help[index++]=arr[p2++];
    }
    for (int i = 0; i < help.length; i++) {
        arr[L+i]=help[i];
    }
}

​ 非递归实现：

//非递归实现
public static void mergeSort2(int[] arr){
    if(arr==null||arr.length<2){
        return ;
    }
    int N=arr.length;
    int mergeSize=1;
    while(mergeSize<N){
        int L=0;
        while(L<N){
            int M=L+mergeSize-1;
            //左组不够了或者根本左组够了，但是右组没有
            if(M>=N){
                break;
            }
            int R=Math.min(M+mergeSize-1,N-1);
            merge(arr,L,M,R);
            L=R+1;
        }
        if(mergeSize>N/2){
           break;
        }
        mergeSize<<=1;
    }
}

测试代码：

// for test
public static int[] generateRandomArray(int maxSize, int maxValue) {
    int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    }
    return arr;
}

// for test
public static int[] copyArray(int[] arr) {
    if (arr == null) {
        return null;
    }
    int[] res = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        res[i] = arr[i];
    }
    return res;
}

// for test
public static boolean isEqual(int[] arr1, int[] arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
        return false;
    }
    if (arr1 == null && arr2 == null) {
        return true;
    }
    if (arr1.length != arr2.length) {
        return false;
    }
    for (int i = 0; i < arr1.length; i++) {
        if (arr1[i] != arr2[i]) {
            return false;
        }
    }
    return true;
}

// for test
public static void printArray(int[] arr) {
    if (arr == null) {
        return;
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
}

// for test
public static void main(String[] args) {
    int testTime = 500000;
    int maxSize = 10;
    int maxValue = 100;
    System.out.println("测试开始");
    for (int i = 0; i < testTime; i++) {
        int[] arr1 = generateRandomArray(maxSize, maxValue);
        int[] arr2 = copyArray(arr1);
        mergeSort1(arr1);
        mergeSort2(arr2);
        if (!isEqual(arr1, arr2)) {
            System.out.println("Oops!Error!");
            printArray(arr1);
            printArray(arr2);
            break;
        }
    }
    System.out.println("测试结束");
}

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z5wiiOeG-1685098557569)(F:\typora插图\image-20230526174128752.png)]

2.小和问题

题意：在一个数组中，一个数左边比它小的数的总和，叫该数的小和，数组中所有数的小和累加起来，叫数组小和。给定一个数组arr，求数组小和。

暴力方法：O(N^2)
归并排序应用：O(NlogN)

解题思路：

  • 注意：ans+=arr[p1]<arr[p2]?(R-p2+1)*arr[p1]:0;在复制之前求
  • 合并过程中计算小和
  • 小和产生规则：左组拷贝产生小和，右组拷贝不产生小和，相等先拷贝右组：小和是左边比当前数小的总和。要的是原数组中的小和。
  • 总体来说，是一个规则的转换：左边有多少数比当前数小转变成右边有多少数比当前数要大。
  • 指针不回退技巧：单调的，已经排好序了

对数器：

  • 穷举遍历

核心代码：

public static int smallSum(int[] arr){
    if(arr==null||arr.length<2){
        return 0;
    }
    return process(arr,0,arr.length-1);
}

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

private static int merge(int[] arr, int L, int M, int R) {
    int ans=0;
    int[] help=new int[R-L+1];
    int index=0;
    int p1=L;
    int p2=M+1;
    while(p1<=M&&p2<=R){
        ans+=arr[p1]<arr[p2]?(R-p2+1)*arr[p1]:0;
        help[index++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
    }
    while(p1<=M){
        help[index++]=arr[p1++];
    }
    while(p2<=R){
        help[index++]=arr[p2++];
    }
    for (int i = 0; i < help.length; i++) {
        arr[L+i]=help[i];
    }
    return ans;
}

测试代码：

// for test
public static int test(int[] arr) {
    if (arr == null || arr.length < 2) {
        return 0;
    }
    int res = 0;
    for (int i = 1; i < arr.length; i++) {
        for (int j = 0; j < i; j++) {
            res += arr[j] < arr[i] ? arr[j] : 0;
        }
    }
    return res;
}

非特殊情况，不再放生成随机数组代码，只放对数器代码。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-87ikTikr-1685098557570)(F:\typora插图\image-20230526175839813.png)]

3.逆序对个数

题意：在一个数组中，任何一个前面的数a，和任何一个后面的数b，如果(a,b)是降序的，就称为降序对。给定一个数组arr，求数组的降序对总数量。

暴力方法：O(N^2)
归并排序应用：O（NlogN）

解题思路：

  • 注意：ans+=arr[p1]>arr[p2]?(p2-M):0;help[index--]=arr[p1]<=arr[p2]?arr[p2--]:arr[p1--];下边拷贝规则相等先右边，上边的顾好！！！！！结合例子反复验算谨慎！！！！！不要再反复改了！醉了…
  • 转换指标：从左向右，当左边比右边大的个数，转换成从右向左，右边比当前左数小的个数
  • 计数规则：左边产生，右边不产生，相等的先拷贝左边的
  • 对应的，归并的顺序改变一下

核心代码：

public static int reversePairNumber(int[] arr){
    if(arr==null||arr.length<2){
        return 0;
    }
    return process(arr,0,arr.length-1);
}

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

private static int merge(int[] arr, int L, int M, int R) {
    int ans=0;
    int[] help=new int[R-L+1];
    int index=help.length-1;
    int p1=M;
    int p2=R;
    while(p1>=L&&p2>=M+1){
        ans+=arr[p1]>arr[p2]?(p2-M):0;
        help[index--]=arr[p1]<=arr[p2]?arr[p2--]:arr[p1--];
    }
    while(p1>=L){
        help[index--]=arr[p1--];
    }
    while(p2>=M+1){
        help[index--]=arr[p2--];
    }
    for (int i = 0; i < help.length; i++) {
        arr[L+i]=help[i];
    }
    return ans;
}

测试代码：

// for test
public static int test(int[] arr) {
    int ans = 0;
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                ans++;
            }
        }
    }
    return ans;
}

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YrJznnb5-1685098557571)(F:\typora插图\image-20230526181737428.png)]

4.大于其2倍右侧数的个数

题意：在一个数组中，对于任何一个数num，求有多少个(后面的数*2)依然<num，返回总个数

暴力方法：O(N^2)
归并排序方法：O(NlogN)

解题思路：

  • 这部分判断逻辑需要单独判断，否则会污染数据或者越界，不容易处理。
  • 本质上来说，归并排序从左向右从右向左均可

核心代码：

public static int reversePairs(int[] arr){
    if(arr==null||arr.length<2){
        return 0;
    }
    return process(arr,0,arr.length-1);
}

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

private static int merge(int[] arr, int L, int M, int R) {
    int ans=0;
    //[L,M],[M+1,R]
    //符合要求的是[M+1,p)
    int p=M+1;
    //遍历左组
    for (int i = L; i <= M; i++) {
        while(p<=R&&(long)arr[i]>(long)arr[p]*2){
            p++;
        }
        ans+=p-M-1;
    }
    int[] help=new int[R-L+1];
    int index=help.length-1;
    int p1=M;
    int p2=R;
    while(p1>=L&&p2>=M+1){
        help[index--]=arr[p1]<=arr[p2]?arr[p2--]:arr[p1--];
    }
    while(p1>=L){
        help[index--]=arr[p1--];
    }
    while(p2>=M+1){
        help[index--]=arr[p2--];
    }
    for (int i = 0; i < help.length; i++) {
        arr[L+i]=help[i];
    }
    return ans;
}

测试代码：

public static int test(int[] arr) {
    int ans = 0;
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > (arr[j] << 1)) {
                ans++;
            }
        }
    }
    return ans;
}

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qxsM0lci-1685098557571)(F:\typora插图\image-20230526184057230.png)]

归并算法总结

算法描述：

基于分治法的一种排序算法，将全序列拆分成子序列，使子序列有序后，再进行合并得到全有序的序列。

复杂度分析及算法评价：

  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(logn)
  • 稳定的算法

改写方法：

  • 抓住指针不回退，单调的即技巧
  • 流程像——顺序决策，与大小有关

例题总结：

  • 归并排序递归实现：
  • 归并排序非递归实现：判断左组存在，判断右组存在，滚成整数最大值，循环停不下来
  • 小和问题：原则——右组拷贝不产生小和，左组拷贝产生小和，相等时先拷贝右组。先计算再拷贝
  • 逆序数对问题：从右向左拷贝；拷贝原则只与左右方向有关，等号斟酌，计算永远在拷贝之前。
  • 左大右的2倍问题：左右无关；可能有数组下标越界风险，单独处理；复制之前的merge记得去掉ans
安苒_
关注
专栏目录
C++排序算法：归并排序详解
小天狼星_布莱克 的博客
07-17 3万+
C++排序算法：归并排序详解
【算法系列 | 4】深入解析排序算法之——归并排序
热门推荐
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
常见排序算法之归并排序——归并排序
保护小周ღ的博客
07-12 2095
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法 （Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序 列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。...
算法 | 基础排序算法：插入排序、选择排序、交换排序、归并排序
TTKunn的博客
09-13 1190
该博客系统阐述了排序算法的概念及运用。详细介绍了插入排序、选择排序、交换排序、归并排序等常见算法的原理与实现方式，分析了其时间复杂度、空间复杂度及稳定性，为深入理解排序算法提供了专业且全面的参考。
排序算法 | 归并排序算法原理及实现和优化
挖坑埋你
10-23 1014
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。 归并排序的原理 归并排序的实现思想是：先将所有的记录完全分开，然后两两合并，在合并的过程中将其排好序并且将已有序的子序列合并，最终能够得到一个完整的有序表。 例...
归并排序算法及优化（java）
weixin_43841461的博客
08-20 1231
归并排序是一种高效且稳定的排序算法，它通过分治策略来实现。本文详细介绍了归并排序的历史背景、工作原理以及其实现细节，并通过一个具体案例展示了归并排序在实际应用中的优势。无论是在理论研究还是实际工程中，归并排序都是一个值得深入了解的重要算法。
C++归并排序算法深度解析
m0_66371692的博客
06-22 924
归并排序算法是一种高效的排序算法，具有稳定的性能和良好的实际应用效果。通过本文的介绍，相信您已经掌握了归并排序算法的原理和C++代码实现。在实际应用中，可以根据具体情况选择合适的优化策略，以提高算法的性能。😄😄😄。
归并排序算法
先写一个BUG吧
08-08 1164
十大经典排序算法之归并排序详解，对归并排序进行原理分析、复杂度分析，列举归并排序的优缺点，内附有C语言描述的实现代码，并对代码进行了全面解析。
排序算法：归并排序，golang实现
幸享龙枫的博客
08-01 1259
在实际场景中，选择合适的排序算法对于提高程序的效率和性能至关重要，本节课主要讲解"归并排序"的适用场景及代码实现。
【排序算法】深入理解归并排序算法：从原理到实现
lmj3732018的博客
03-05 5321
归并排序是一种经典的排序算法，它的核心思想是分治和递归。通过将待排序序列分割成若干个子序列，分别对子序列进行排序，然后将排好序的子序列合并成有序序列。本文将从原理、时间复杂度、应用场景、优缺点等方面深入探讨归并排序算法，并通过 Java、JavaScript 和 Python 三种编程语言的示例进行说明。
我最喜欢的排序算法 快速排序和归并排序.doc
05-07
快速排序和归并排序是两种高效且广泛应用的排序算法，它们在时间和空间复杂度上有各自的特点。 快速排序是由英国计算机科学家C.A.R. Hoare在1960年提出的，其核心思想是“分治”策略。算法首先选择一个基准元素，...
qiuwww#blog#5.归并排序1
07-25
归并排序原理|介绍归并排序归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法
归并排序算法详解与实现.zip
06-17
通过深入学习这些资料，你可以理解归并排序的工作原理，并能够编写自己的归并排序实现，同时了解如何在实际项目中选择和应用合适的排序算法。这将有助于提升你在算法设计和数据结构方面的技能，对于学习交流和职业...
快速排序与归并排序比较(C++).rar_c++paixusuanfa_归并_归并排序_归并排序算法
09-19
快速排序和归并排序是两种常用的排序算法，它们在计算机科学和编程中有着广泛的应用。本文将详细讨论这两种排序算法的原理、实现方式以及性能对比。 快速排序是一种由C.A.R. Hoare在1960年提出的分治算法。其基本...
C++冒泡、快速、选择、归并等排序算法实现示例.rar
05-07
本资料包包含C++实现的四种经典排序算法：冒泡排序、快速排序、选择排序和归并排序。下面将分别对这四种排序算法进行详细介绍，并探讨它们的原理、效率和适用场景。 **1. 冒泡排序（Bubble Sort）** 冒泡排序是最...
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 263
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 199
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 183
100种算法【Python版】第51篇——希尔排序
深⼊理解指针2
ElePower9527的博客
11-01 680
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值