算法— — 归并排序的应用

最新推荐文章于 2023-02-24 01:05:09 发布
最新推荐文章于 2023-02-24 01:05:09 发布
阅读量249 收藏 2
点赞数
分类专栏： LeetCode 算法与数据结构 文章标签： 算法 排序算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/126242239
版权

算法题目— — 归并排序的应用

1 递归排序代码

递归排序流程

  • mergeSort(int[] arr)
  • process(int[] arr, int L, int R);
  • merge(int[] arr, int L, int M, int R)
package com.ali.test;


import java.util.Arrays;

public class MergeSortTest {
    public static void main(String[] args) {
        int[] arr = {3,5,1,5,1,6,62,0,80,-1,41,5108,54180,84,-45180,15,64};
        int[] arr2 = {3,5,1,5,1,6,62,0,80,-1,41,5108,54180,84,-45180,15,64};
        Arrays.sort(arr);
        print(arr);
        System.out.println();
        mergeSort(arr2);
        print(arr2);
    }
    //归并排序[递归方法实现]
    public static void mergeSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        process(arr, 0, arr.length - 1);

    }
    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;
        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++];
        }
        for(i = 0; i < help.length; ){
            arr[L++] = help[i++];
        }

    }


    public static void print(int[] arr){
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

}

2 递归排序应用

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

主要思路：在递归排序的基础上，if (arr[p1] < arr[p2]) then res+= arr[p1]* (R - p2 + 1) ,否则res+=0
代码：

package com.ali.test;

public class SmallSumTest {

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

    /**
     * arr[L, R]既要排好序，也要求小和返回
     * 所有merge时，产生的小和，累加
     * @param arr
     * @param l
     * @param r
     * @return
     */
    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){
            //关键步骤：
            //L: 1 3 7 8
            //R: 1 2 4 9
            //(R - p2 + 1) * arr[p1] 左边总共小的数的sum
            //等于的话，走右边
            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(i = 0; i < help.length; i++){
            arr[L+i] = help[i];
        }
        return res;
    }



    // for test
    public static int comparator(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;
    }

    // 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 = 100;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            if (smallSum(arr1) != comparator(arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }
}

2.2 求数组中所有逆序对

在这里插入图片描述

思路:
和上面小和问题类似，只不过是反过来遍历数组
int p1 = M;
int p2 = R;
while(p1 >= L && p2 > M){
    res += arr[p1] > arr[p2] ? (p2 - M) : 0;
…
}

package com.ali.math.class_04;

public class ReversePairTest {

    /**
     * 求逆序对
     * @param arr
     * @return
     */
    public static int reversePairNum(int[] arr){
        if(arr == null || arr.length < 2){
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    /**
     * arr[L, R]既要排好序，也要对逆序对数量进行返回
     * @param arr
     * @param l
     * @param r
     * @return
     */
    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 = help.length - 1;
        int p1 = m;
        int p2 = r;
        int res = 0;
        while(p1 >= l && p2 > m){
            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
            //等于情况走右边
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while(p1 >= l){
            help[i--] = arr[p1--];
        }
        while(p2 > m){
            help[i--] = arr[p2--];
        }
        //拷贝回原数组
        for (i = 0; i < help.length; i++) {
            arr[l+i] = help[i];
        }
        return res;
    }

    // for test
    public static int comparator(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;
    }

    // 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 = 100;
        int maxValue = 100;
        System.out.println("测试开始");
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            if (reversePairNum(arr1) != comparator(arr2)) {
                System.out.println("Oops!");
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        System.out.println("测试结束");
    }
}

2.3 翻转对

在这里插入图片描述
在一个数组中，对于每个数num，求有多少个后面的数*2<num,求总个数
比如：[3,1,7,0,2]
3的后面有：1，0
1的后面有：0
7的后面有：0，2
0的后面没有
2的后面没有
所以总共有5个

关键思路：
依然是利用归并排序

int res = 0;
int windowR = m + 1;
for(int i = L; i <= m; i++){
	while(windowR <= r && (long)arr[i] > (long)arr[windowR]*2){
		windowR++;//继续向右边滑动，直到不大于为止
	}
	res += windowR - m - 1;
}

全部代码：

//归并排序解法：
class Solution {
    public int reversePairs(int[] nums) {
        if(nums == null || nums.length < 2){
            return 0;
        }
        return process(nums, 0, nums.length - 1);
    }
    
    public int process(int[] arr, int l, int r){
        if(l == r){
            return 0;
        }
        int m = l + ((r - l) >> 1);
        return process(arr, l, m) + process(arr, m+1, r) + merge(arr, l, m, r);
    }
    public int merge(int[] arr, int l, int m, int r){
        int[] help = new int[r - l + 1];
        int res = 0;
        //进行判断
        int windowR = m + 1;
        for(int i = l; i <= m; i++){
            while(windowR <= r && (long)arr[i] > (long)arr[windowR] * 2){
                windowR++;
            }
            res += windowR - m - 1;
        }
        int i = 0;
        int p1 = l;
        int p2 = m+1;
        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++];
        }
        for(i = 0; i < help.length; i++){
            arr[l+i] = help[i];
        }
        return res;
    }
}

2.4 区间和的个数

在这里插入图片描述

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        //前缀和数组
        long[] sum = new long[nums.length];
        sum[0] = nums[0];
        for(int i = 1; i < nums.length; i++){
            sum[i] = sum[i-1] + nums[i];
        }
        return process(sum, 0, sum.length - 1, lower, upper);
    }
    public int process(long[] sum, int l, int r, int lower, int upper){
        if(l == r){
            return sum[l] >= lower && sum[l] <= upper ? 1 : 0;
        }
        int m = l + ((r - l) >> 1);
        return process(sum, l, m, lower, upper) + process(sum, m + 1, r, lower, upper) 
            + merge(sum, l, m, r, lower, upper);
    }
    
    public int merge(long[] arr, int l, int m, int r, int lower, int upper){
        int ans = 0;
        int windowL = l;
        int windowR = l;
        for(int i = m + 1; i <= r; i++){
            long min = arr[i] - upper;
            long max = arr[i] - lower;
            while(windowR <= m && arr[windowR] <= max){
                windowR++;
            }
            //[)
            while(windowL <= m && arr[windowL] < min){
                windowL++;
            }
            ans += windowR - windowL;//sum是前缀和，因此这个减下来是个数
        }
        long[] help = new long[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m+1;
        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++];
        }
        for(i = 0; i < help.length; i++){
            arr[l+i] = help[i];
        }
        return ans;
    }
}
NPE~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
归并排序之应用
小桥流水
12-07 331
1. 利用归并排序查找左右边界327. 区间和的个数 vector<long> tmp; int merge(vector<long> &sum,int l,int r,int &lower,int &upper){ if(r<=l) return 0; //若前缀和数组从一开始，仅需要改变该处，针对单个元素，return sum[l]>=lower&&sum[l...
C#排序算法之归并排序
12-20
归并排序是一种高效的排序算法，属于分治策略的典型应用。在C#中，我们可以用递归的方式来实现归并排序。归并排序的基本思想是将待排序的元素序列分为两个子序列，分别对这两个子序列进行排序，然后将排好序的子序列...
归并排序及其应用场景
森明帮大于黑虎帮的博客
09-20 1927
文章目录一、归并排序的概念二、归并排序递归与非递归实现三、归并排序应用场景四、归并排序总结 一、归并排序的概念 二、归并排序递归与非递归实现 归并排序递归实现，分治为每个区间元素都有序，那么就得把区间 分治成为1才能保证区间中每个元素都有序，在归并： //归并排序 void _MergeSort(int*arr, int left, int right, int* tmp) { if (left >= right) { return; } int mid = left + (right
归并排序的应用
q_all_is_well的博客
05-22 968
昨天总结了一下几种常用的排序算法，而且，在比较排序算法的结尾有一个小tips：堆排序和归并排序都是渐进最有的比较排序算法。今天在回顾算法导论的过程中发现，堆排序，快排，归并排序的应用很广泛，重要的不是这种排序的方式，而是这种排序的思想值得我们学习。归并排序思想的应用主要是递归+划分。实际应用有小和问题，逆序对问题。...
归并排序详解及应用
c630843901的博客
07-01 599
就这么说吧，所有递归的算法，你甭管它是干什么的，本质上都是在遍历一棵（递归）树，然后在节点（前中后序位置）上执行代码，你要写递归算法，本质上就是要告诉每个节点需要做什么。你看归并排序的代码框架: 看这个框架，也就明白那句经典的总结：归并排序就是先把左半边数组排好序，再把右半边数组排好序，然后把两半数组合并。上述代码和二叉树的后序遍历很像： 前文 二叉树（纲领篇） 说二叉树问题可以分为两类思路，一类是遍历一遍二叉树的思路，另一类是分解问题的思路，根据上述类比，显然归并排序利用的是分解问题的思路归并排序的过程可
归并排序及其应用
最新发布
qq_49005782的博客
02-24 206
排序算法的一些应用
C++归并排序算法实例
09-04
归并排序（Merge Sort）是一种基于分治策略的高效排序算法。它的基本思想是将待排序的序列分为两部分，分别对这两部分进行排序，然后再将排好序的子序列合并成一个完整的有序序列。这一过程不断递归进行，直到每个子...
java实现归并排序算法
09-03
归并排序是一种高效的排序算法，它的基本思想是利用分治法（Divide and Conquer）将大问题分解为小问题来解决。分治法的核心在于将一个复杂的问题分解成两个或更多的相同或相似的子问题，再将子问题分解成更小的子...
分治算法——归并排序
12-21
虽然它的空间需求比原地排序算法如快速排序高，但归并排序具有稳定性，即相等元素的相对顺序在排序后不会改变，这在某些应用场景中是必要的。 总结来说，归并排序是一种高效且稳定的排序算法，利用分治策略将排序...
归并算法及其归并算法的应用
小树的博客
03-04 633
1.归并排序 public class MergeSort { public static void mergeSort(int[] arr) { if (arr == null || arr.length < 2) { return; } mergeSort(arr, 0, arr.length - 1); } public static void...
归并排序算法的实现及应用
醒醒康康博客
05-07 360
归并排序，采用了递归的思想，先将左半部分排好序，再将右半部分排好序，最后将两个排序好的数组进行外排序。 时间复杂度为O(N*logN) 递归排序的代码如下： public class MergeSort { public static void mergeSort(int[] arr){ if(arr == null || arr.length < 2) re...
【算法训练】归并排序的应用
GUANYX的博客
05-25 163
一、翻转对 493 1、分析 首先看到i<j这个条件，就想到了数组分为左右两个部分，然后分别在左右两个部分去找满足条件的翻转对。由于在归并排序的过程中每一步都会访问到不同的左右数组部分，所以考虑在归并排序的框架上进行操作。就在左右两个数组将要合并的时候，利用左右数组i肯定小于j，且左右两个数组都是有序的条件去解题。 具体看代码及注释。 2、代码 这里需要注意的就是在寻找i，j对的时候充分利用左右子数组的有序性，让end不要回退，从而降低时间复杂度！ class Solution: def r
归并排序算法实现思想个人理解
热门推荐
CurryCoder的个人博客
05-30 1万+
1.原理：假设初始待排序数据有n个，可以将n个数据看成n个独立的子序列，因此每个子序列的长度为1，然后两两合并，得到[n/2]个长度为2或1(注意如果n为奇数时，就会出现多出一个元素无法与其他元素合并)的有序子序列;再两两合并，一种重复下去，直到得到一个长度为n的有序序列为止，这种排序方法为2路排序方法。 2.递归方法来实现归并排序 原理：使用递归方法来实现归并排序时，核心思想是两个有序子序...
归并排序及其应用 c++实现
woshinannan的专栏
10-13 767
归并排序是基于分治的思想，分治策略：将原问题划分为n个规模较小的并且结构与原问题相似的子问题，递归的解决这些子问题，然后合并其结果，得到的就是原问题的解了。 分治的模式在每一层的递归上都有三个步骤： 1、 分解：将原问题分解为一系列的子问题 2、 解决: 递归的解决各个子问题。若子问题足够的小，则直接求解。 3、 合并：将子问题的结果合并，变为原问题的解。归并算法完全依照于分治的策略： 1
归并排序思想应用
yutianxin123的专栏
08-25 1030
今天刷剑指offer第36题，求逆序数。要求时间复杂度尽可能小。先看下我原来的代码。 #include using namespace std; class Solution { public: int InversePairsCore(vector&data,vector&copy,long start,long end) { if(start>end)
归并排序应用-----求逆序数
qq_40447680的博客
01-23 223
归并排序是冒泡排序的一种升级版排序，其灵魂是二分思想加上冒泡，在二分的基础上进行冒泡排序，可以将原来时间复杂度为O(n^2)的冒泡排序降低为O(logn)的归并排序。 下面我们先来看归并排序，之后再来讲归并排序的应用—求逆序数 归并排序 前面提到，归并排序采用的是二分思想，我们先把一段需要排序的序列分成两半，是不是每一段的交换次数就会变少，然后我们又将分成的两段，继续分成四段，以此类推，直到分到每...
【分治的典型应用：归并排序】
Alex
02-12 324
分析 数组排序任务可以如下完成： 1.把前一半排序 2.把后一半排序 3.把两半归并到到一个新的有序数组，然后再拷贝回原数组，排序完成。 归并排序的时间复杂度 对n个元素进行排序的时间： T(n)=2T(n/2)+an （a是常数，具体多少不重要） =2T(sT(n/4)+an/2)+an =4T(n/4)+2an …… =2k*T(n/2k)+kan 一直做到n/2^k=1(此时k...
比较选择排序与归并排序：算法详解与应用
归并排序则是分治策略的典型应用，将数组分为两半，分别排序后再合并。它的效率更高，一般采用递归的方式，将大问题分解为小问题，直至子问题规模足够小可以直接解决。归并排序具有稳定的特性，即相等的元素排序后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值