devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

排序算法——归并排序的相关问题_归并算法一组个数远小于另一组

作者：小蓝xlanll | 2024-03-13 03:30:54

赞

踩

归并算法一组个数远小于另一组

一、小和问题

问题描述，给定一个数组，如[1, 3, 2, 6, 5]，计算每个数左边小于自己的所有数的和，并累加。例如：

1左边没有数

3左边有一个小于自己的数 1

2左边有一个小于自己的数 1

6左边有三个小于自己的数 1 + 3 + 2 = 6

5左边有三个小于自己的数 1 + 3 + 2 = 6

最后 1 + 1 + 6 + 6 = 14，上面给定数组 [1, 3, 2, 6, 5] 的小和解就是 14.

解题思路：这道题的常规思路是循环每个数，然后再遍历它左边的所有数，只要比自己小，就累加到 sum 上。时间复杂度是 O(N^2)。

如何将它改写成 O(N^logN)复杂度的算法？可以利用递归。

本题中我们要计算每个数左侧小于自己数的和，反过来看，就是每个数算一下右边有几个大于自己的数，然后求和。还是以上面的数组为例：

1右边有四个数大于自己，4 * 1 = 4

3右边有两个数大于自己，2 * 3 = 6

2右边有两个数大于自己，2 * 2 = 4

6右边没有大于自己的数

5右边没有大于自己的数

最后 4 + 6 + 4 = 14，和前一种按照题意原本的规则计算的结果完全一致。

有了这个逆向思路，我们可以在归并排序 merge 的时候，由于merge的左右两组一定是有序的，在左组数较小并拷贝时计算右组中大于自己的数的个数乘以自身就，就可以得到一个当前范围内右侧累计值：

上图是一个常规的非对称情况的 merge 操作，其中 1 3 已经通过merge排好序（尽管已经是有序的，但也会执行一次merge）。

在merge的时候，左组拷贝产生小和，右组拷贝不产生小和。根据之前的逆向思路，我们需要计算每个数右组比自己大的元素个数，由于已经有了“左右两组各自有序”这个前提，因此在copy左组元素的时候，直接取右组当前比较的位置到 R 的元素个数即可，而当左右两组当前比较的元素相等时，我们必须先拷贝右组元素，这是为了方便计算右组有几个数大于左组：

实现及测试完整代码：

  1. /**
  2.  * 小和问题
  3.  */
  4. public class Code2_SmallSum {
  5.  
  6.     public static int smallSum(int[] arr) {
  7.         if (arr == null || arr.length < 2)
  8.             return 0;
  9.         return process(arr, 0, arr.length - 1);
  10.     }
  11.  
  12.     private static int process(int[] arr, int L, int R) {
  13.         if (L == R)
  14.             return 0;
  15.         int M = L + ((R - L) >> 1);
  16.         int leftSum = process(arr, L, M);
  17.         int rightSum = process(arr, M + 1, R);
  18.         int mergeSum = merge(arr, L, M, R);
  19.         return leftSum + rightSum + mergeSum;
  20.     }
  21.  
  22.     private static int merge(int[] arr, int L, int M, int R) {
  23.         int[] help = new int[R - L + 1];
  24.         int p1 = L;
  25.         int p2 = M + 1;
  26.         int i = 0;
  27.         int res = 0;
  28.         while (p1 <= M && p2 <= R) {
  29.             res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
  30.             help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
  31.         }
  32.         while (p1 <= M) {
  33.             help[i++] = arr[p1++];
  34.         }
  35.         while (p2 <= R) {
  36.             help[i++] = arr[p2++];
  37.         }
  38.         for (i = 0; i < help.length; i++) {
  39.             arr[L + i] = help[i];
  40.         }
  41.         return res;
  42.     }
  43.  
  44.  
  45.     // for test
  46.     public static int comparator(int[] arr) {
  47.         if (arr == null || arr.length < 2) {
  48.             return 0;
  49.         }
  50.         int res = 0;
  51.         for (int i = 1; i < arr.length; i++) {
  52.             for (int j = 0; j < i; j++) {
  53.                 res += arr[j] < arr[i] ? arr[j] : 0;
  54.             }
  55.         }
  56.         return res;
  57.     }
  58.  
  59.     // for test
  60.     public static int[] generateRandomArray(int maxSize, int maxValue) {
  61.         int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
  62.         for (int i = 0; i < arr.length; i++) {
  63.             arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
  64.         }
  65.         return arr;
  66.     }
  67.  
  68.     // for test
  69.     public static int[] copyArray(int[] arr) {
  70.         if (arr == null) {
  71.             return null;
  72.         }
  73.         int[] res = new int[arr.length];
  74.         for (int i = 0; i < arr.length; i++) {
  75.             res[i] = arr[i];
  76.         }
  77.         return res;
  78.     }
  79.  
  80.     // for test
  81.     public static boolean isEqual(int[] arr1, int[] arr2) {
  82.         if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
  83.             return false;
  84.         }
  85.         if (arr1 == null && arr2 == null) {
  86.             return true;
  87.         }
  88.         if (arr1.length != arr2.length) {
  89.             return false;
  90.         }
  91.         for (int i = 0; i < arr1.length; i++) {
  92.             if (arr1[i] != arr2[i]) {
  93.                 return false;
  94.             }
  95.         }
  96.         return true;
  97.     }
  98.  
  99.     // for test
  100.     public static void printArray(int[] arr) {
  101.         if (arr == null) {
  102.             return;
  103.         }
  104.         for (int i = 0; i < arr.length; i++) {
  105.             System.out.print(arr[i] + " ");
  106.         }
  107.         System.out.println();
  108.     }
  109.  
  110.     // for test
  111.     public static void main(String[] args) {
  112.         int testTime = 500000;
  113.         int maxSize = 100;
  114.         int maxValue = 100;
  115.         boolean succeed = true;
  116.         for (int i = 0; i < testTime; i++) {
  117.             int[] arr1 = generateRandomArray(maxSize, maxValue);
  118.             int[] arr2 = copyArray(arr1);
  119.             if (smallSum(arr1) != comparator(arr2)) {
  120.                 succeed = false;
  121.                 printArray(arr1);
  122.                 printArray(arr2);
  123.                 break;
  124.             }
  125.         }
  126.         System.out.println(succeed ? "Nice!" : "Fucking fucked!");
  127.     }
  128.  
  129. }

二、逆序对个数问题

逆序对个数是经典考题，也是常考题，它的问题是这样的：

给定一个数组，如 [1, 3, 2, 6, 4] ，在整个数组范围内，只要两个数形成降序，即判定为一个逆序对，统计这个数组的逆序对个数：

以上述数组为例，3, 2  和 6，4都是逆序对，因此该数组总共有两个逆序对。

题意非常好理解，同时它也是上题小和问题的一个变种，上面的小和问题通过逆向思维，实际上计算的是右侧有几个比自己大的数，然后累乘自身，而本题是求右侧有多少个比自己小，累加。

那么以升序排序的方式可以求右组比自己大的个数，同理，以降序排序的方式就可以求右组比自己小的个数。因此，只需要降序merge，并统计个数即可，完整代码和测试如下：

  1. /**
  2.  * 逆序对个数
  3.  */
  4. public class Code2_ReversedPair {
  5.  
  6.     /**
  7.      * 降序，再count
  8.      */
  9.     public static int reversedPairCount(int[] arr) {
  10.         if (arr == null || arr.length < 2)
  11.             return 0;
  12.         return process(arr, 0, arr.length - 1);
  13.     }
  14.  
  15.     private static int process(int[] arr, int L, int R) {
  16.         if (L == R)
  17.             return 0;
  18.         int M = L + ((R - L) >> 1);
  19.         return process(arr, L, M) + process(arr, M + 1, R) + merge(arr, L, M, R);
  20.     }
  21.  
  22.     private static int merge(int[] arr, int L, int M, int R) {
  23.         int[] help = new int[R - L + 1];
  24.         int p1 = L;
  25.         int p2 = M + 1;
  26.         int i = 0;
  27.         int count = 0;
  28.         while (p1 <= M && p2 <= R) {
  29.             count += arr[p1] > arr[p2] ? (R - p2 + 1) : 0;
  30.             help[i++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
  31.         }
  32.         while (p1 <= M) {
  33.             help[i++] = arr[p1++];
  34.         }
  35.         while (p2 <= R) {
  36.             help[i++] = arr[p2++];
  37.         }
  38.         for (i = 0; i < help.length; i++) {
  39.             arr[L + i] = help[i];
  40.         }
  41.         return count;
  42.     }
  43.  
  44.     // for test
  45.     public static int comparator(int[] arr) {
  46.         int ans = 0;
  47.         for (int i = 0; i < arr.length; i++) {
  48.             for (int j = i + 1; j < arr.length; j++) {
  49.                 if (arr[i] > arr[j]) {
  50.                     ans++;
  51.                 }
  52.             }
  53.         }
  54.         return ans;
  55.     }
  56.  
  57.     // for test
  58.     public static int[] generateRandomArray(int maxSize, int maxValue) {
  59.         int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
  60.         for (int i = 0; i < arr.length; i++) {
  61.             arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
  62.         }
  63.         return arr;
  64.     }
  65.  
  66.     // for test
  67.     public static int[] copyArray(int[] arr) {
  68.         if (arr == null) {
  69.             return null;
  70.         }
  71.         int[] res = new int[arr.length];
  72.         for (int i = 0; i < arr.length; i++) {
  73.             res[i] = arr[i];
  74.         }
  75.         return res;
  76.     }
  77.  
  78.     // for test
  79.     public static boolean isEqual(int[] arr1, int[] arr2) {
  80.         if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
  81.             return false;
  82.         }
  83.         if (arr1 == null && arr2 == null) {
  84.             return true;
  85.         }
  86.         if (arr1.length != arr2.length) {
  87.             return false;
  88.         }
  89.         for (int i = 0; i < arr1.length; i++) {
  90.             if (arr1[i] != arr2[i]) {
  91.                 return false;
  92.             }
  93.         }
  94.         return true;
  95.     }
  96.  
  97.     // for test
  98.     public static void printArray(int[] arr) {
  99.         if (arr == null) {
  100.             return;
  101.         }
  102.         for (int i = 0; i < arr.length; i++) {
  103.             System.out.print(arr[i] + " ");
  104.         }
  105.         System.out.println();
  106.     }
  107.  
  108.     // for test
  109.     public static void main(String[] args) {
  110.         int testTime = 500000;
  111.         int maxSize = 100;
  112.         int maxValue = 100;
  113.         System.out.println("测试开始");
  114.         for (int i = 0; i < testTime; i++) {
  115.             int[] arr1 = generateRandomArray(maxSize, maxValue);
  116.             int[] arr2 = copyArray(arr1);
  117.             if (reversedPairCount(arr1) != comparator(arr2)) {
  118.                 System.out.println("Oops!");
  119.                 printArray(arr1);
  120.                 printArray(arr2);
  121.                 break;
  122.             }
  123.         }
  124.         System.out.println("测试结束");
  125.     }
  126. }

三、两倍大问题

两倍大问题，给定一个数组，如[6, 7, 1, 3, 2]，计算出每个数右侧比自身要小两倍还多的数的累计个数。

  1. /**
  2.  * 两倍大问题：统计数组中每个比右边几个数两倍还大。
  3.  * 6 7 1 3 2，
  4.  * 6比1、2 大两倍还多
  5.  * 7比1、3、2大两倍还多
  6.  * 因此总个数就是5个
  7.  */
  8. public class Code4_BeggerTwice {
  9.  
  10.     public static int biggerTwice(int[] arr) {
  11.         if (arr == null || arr.length < 2)
  12.             return 0;
  13.         int count = process(arr, 0, arr.length - 1);
  14.         return count;
  15.     }
  16.  
  17.     private static int process(int[] arr, int L, int R) {
  18.         if (L == R)
  19.             return 0;
  20.         int M = L + ((R - L) >> 1);
  21.         return process(arr, L, M) + process(arr, M + 1, R) + merge(arr, L, M, R);
  22.     }
  23.  
  24.     private static int merge(int[] arr, int L, int M, int R) {
  25.         int[] help = new int[R - L + 1];
  26.         int i = 0;
  27.         int p1 = L;
  28.         int p2 = M + 1;
  29.         int count = 0;
  30.         // [M + 1, R]
  31.         int windowR = M + 1;
  32.         for (int j = L; j <= M; j++) {
  33.             while (windowR <= R && arr[j] <= arr[windowR] * 2)
  34.                 windowR++;
  35.             count += R - windowR + 1;
  36.         }
  37.         while (p1 <= M && p2 <= R) {
  38.             help[i++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
  39.         }
  40.         while (p1 <= M) {
  41.             help[i++] = arr[p1++];
  42.         }
  43.         while (p2 <= R) {
  44.             help[i++] = arr[p2++];
  45.         }
  46.         for (i = 0; i < help.length; i++) {
  47.             arr[L + i] = help[i];
  48.         }
  49.         return count;
  50.     }
  51.  
  52.     // for test
  53.     public static int comparator(int[] arr) {
  54.         int ans = 0;
  55.         for (int i = 0; i < arr.length; i++) {
  56.             for (int j = i + 1; j < arr.length; j++) {
  57.                 if (arr[i] > (arr[j] << 1)) {
  58.                     ans++;
  59.                 }
  60.             }
  61.         }
  62.         System.out.println("arr2总数为：" + ans);
  63.         return ans;
  64.     }
  65.  
  66.     // for test
  67.     public static int[] generateRandomArray(int maxSize, int maxValue) {
  68.         int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
  69.         for (int i = 0; i < arr.length; i++) {
  70.             arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1) * Math.random());
  71.         }
  72.         return arr;
  73.     }
  74.  
  75.     // for test
  76.     public static int[] copyArray(int[] arr) {
  77.         if (arr == null) {
  78.             return null;
  79.         }
  80.         int[] res = new int[arr.length];
  81.         for (int i = 0; i < arr.length; i++) {
  82.             res[i] = arr[i];
  83.         }
  84.         return res;
  85.     }
  86.  
  87.     // for test
  88.     public static boolean isEqual(int[] arr1, int[] arr2) {
  89.         if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
  90.             return false;
  91.         }
  92.         if (arr1 == null && arr2 == null) {
  93.             return true;
  94.         }
  95.         if (arr1.length != arr2.length) {
  96.             return false;
  97.         }
  98.         for (int i = 0; i < arr1.length; i++) {
  99.             if (arr1[i] != arr2[i]) {
  100.                 return false;
  101.             }
  102.         }
  103.         return true;
  104.     }
  105.  
  106.     // for test
  107.     public static void printArray(int[] arr) {
  108.         if (arr == null) {
  109.             return;
  110.         }
  111.         for (int i = 0; i < arr.length; i++) {
  112.             System.out.print(arr[i] + " ");
  113.         }
  114.         System.out.println();
  115.     }
  116.  
  117.     // for test
  118.     public static void main(String[] args) {
  119.         int testTime = 500000;
  120.         int maxSize = 10;
  121.         int maxValue = 10;
  122.         System.out.println("测试开始");
  123.         for (int i = 0; i < testTime; i++) {
  124.             int[] arr1 = generateRandomArray(maxSize, maxValue);
  125. //            System.out.println("原始数组：==========");
  126. //            printArray(arr1);
  127.             int[] arr2 = copyArray(arr1);
  128.             if (biggerTwice(arr1) != comparator(arr2)) {
  129.                 System.out.println("Oops!");
  130.                 printArray(arr1);
  131.                 printArray(arr2);
  132.                 break;
  133.             }
  134.         }
  135.         System.out.println("测试结束");
  136.     }
  137.  
  138.  
  139. }

四、求区间和子数组个数

本题是LeetCode真题——327题区间和个数：https://leetcode-cn.com/problems/count-of-range-sum/

提议描述：给定一个数组 arr，两个整数 lower 和 upper，计算出 arr 中有多少个子数组的累加和在 [lower, upper] 范围上，要求子数组必须连续。

例如，[1, 3, -2] ，求累加和范围在 [2, 4] 范围上的子数组个数：

[1] 不符合

[1, 3] 符合

[1, 3, -2] 符合

[3] 符合

[3, -2] 不符合

[-2] 不符合

所以，符合达标的子数组分别是[1, 3]、[1, 3, -2]、[3] ，共 3 个子数组。

小提示：枚举子数组的方式有两种，一种是以头位置开始，上面就是这种方式，还有一种是以尾为标准，例如：

以 0 位置结尾的子数组：[1]

以 1 位置结尾的子数组：[1, 3]、[3]、

以 2 位置结尾的子数组：[1,3,-2]、[3, -2]、[-2]

解题思路：这是一道困难难度的面试题。在解答本题之前，需要有一些转换技巧作为铺垫——前缀和问题。

前缀和问题的描述是，一个数组 arr[] ，元素是无序整数，正负0都有，给定一个 [i, j] 范围，求累加和。这个问题可以算得上是区间和问题的一个重要逻辑单元。

最傻瓜式的方式无非就是从 i 到 j 遍历元素，然后累加。如何优化？可以转变成“前缀和问题”。

求[0, j] 累加和，减去[0，i - 1] 范围的累加和，即可得到 [i, j] 范围的累加和。我们称之为“前缀和”，就是因为每个位置的前缀和都是从0位置开始一直加到自身位置，而每个位置上的前缀和只需要遍历一遍就可以轻松得出。

如果我们实现通过一次遍历得到了和原数组每个位置元素对应的前缀和，那么 [i, j] 累加和问题就可以轻松变为从前缀和数组中取 j 和 i 位置上的两个数，然后相减，抛去只执行一次的前缀和数组的生成，后面的每次操作都是常数时间复杂度，极大地提升了效率。

  1.     public static int rangeSum(int[] arr, int lower, int upper) {
  2.         if (arr == null || lower < 0 || upper >= arr.length)
  3.             throw new IllegalArgumentException("参数不合法");
  4.         int[] preSum = new int[arr.length];
  5.         preSum[0] = arr[0];
  6.         for (int i = 1; i < arr.length; i++) {
  7.             preSum[i] = preSum[i - 1] + arr[i];
  8.         }
  9.         return preSum[upper] - preSum[lower - 1];
  10.     }

有了以上这些知识的铺垫，再来回看原题，求累加和属于 [lower, upper] 范围的子数组个数，如果有了原数组对应的前缀和数组，假设以 i 位置为例，求以 i 位置结尾的子数组累加和属于 [lower, upper] 范围，对应前缀和数组，就是求以 i 位置结尾的前缀和与多少个左侧前缀和相减的差属于[lower, upper] ，如果 i 位置上的前缀和为 x，那么这个 i 位置左侧的小前缀和的区间范围就应该落在与其互补的 [x - upper, x - lower] 范围上，简言之就是求前缀和数组上，i 位置左侧有多少个元素属于 [x-upper, x - lower] 范围，由于我们一定可以通过以各个位置上的数结尾的子数组穷举全部子数组，因此利用归并求出每个 i 位置左侧达标的元素并计数，最终就一定会统计出全部达标的子数组个数。

上图中，移位换项指的是  i - j = [lower, upper] ，将 j 移到一侧，得出 j = [i - lower, i - upper] 。

完整代码如下： 

  1. public class Code1_CountOfRangeSum {
  2.  
  3.     public static int countRangeSum(int[] arr, int lower, int upper) {
  4.         if (arr == null || arr.length == 0)
  5.             throw new IllegalArgumentException("参数非法！");
  6.         long[] preSum = new long[arr.length];
  7.         preSum[0] = arr[0];
  8.         for (int i = 1; i < arr.length; i++) {
  9.             preSum[i] = preSum[i - 1] + arr[i];
  10.         }
  11.         return process(preSum, 0, preSum.length - 1, lower, upper);
  12.     }
  13.  
  14.     private static int process(long[] preSum, int L, int R, int lower, int upper) {
  15.         if (L == R)
  16.             return preSum[L] >= lower && preSum[L] <= upper ? 1 : 0;
  17.         int M = L + ((R - L) >> 1);
  18.         return process(preSum, L, M, lower, upper)
  19.                 + process(preSum, M + 1, R, lower, upper)
  20.                 + merge(preSum, L, M, R, lower, upper);
  21.     }
  22.  
  23.     private static int merge(long[] preSum, int L, int M, int R, int lower, int upper) {
  24.         int count = 0;
  25.         int windowL = L;
  26.         int windowR = L;
  27.         // [windowL, windowR)
  28.         for (int i = M + 1; i <= R; i++) {
  29.             long min = preSum[i] - upper;
  30.             long max = preSum[i] - lower;
  31.             while (windowR <= M && preSum[windowR] <= max)
  32.                 windowR++;
  33.             while (windowL <= M && preSum[windowL] < min)
  34.                 windowL++;
  35.             count += windowR - windowL;
  36.         }
  37.         long[] help = new long[R - L + 1];
  38.         int i = 0;
  39.         int p1 = L;
  40.         int p2 = M + 1;
  41.         while (p1 <= M && p2 <= R) {
  42.             help[i++] = preSum[p1] <= preSum[p2] ? preSum[p1++] : preSum[p2++];
  43.         }
  44.         while (p1 <= M)
  45.             help[i++] = preSum[p1++];
  46.         while (p2 <= R)
  47.             help[i++] = preSum[p2++];
  48.         for (i = 0; i < help.length; i++) {
  49.             preSum[L + i] = help[i];
  50.         }
  51.         return count;
  52.     }
  53. }

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/227557
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号