【算法系列篇】分治-归并

在这里插入图片描述

文章目录

  • 前言
  • 什么是归并算法
  • 1. 排序数组
    • 1.1 题目要求
    • 1.2 做题思路
    • 1.3 Java代码实现
  • 2. 数组中逆序对
    • 2.1 题目要求
    • 2.2 做题思路
    • 2.3 Java代码实现
  • 3. 计算右侧小于当前元素的个数
    • 3.1 题目要求
    • 3.2 做题思路
    • 3.3 Java代码实现
  • 4. 翻转对
    • 4.1 题目要求
    • 4.2 做题思路
    • 4.3 Java代码实现
  • 总结

前言

上一篇算法文章，我们介绍了分治-快排的算法，今天我将为大家分享关于分治的另外一种算法——归并。

什么是归并算法

在这里插入图片描述
归并算法是一种常用的排序算法，它采用分治策略将待排序的数组分解为更小的子数组，然后逐步合并这些子数组以获得最终的有序数组。归并排序的主要思想是将两个有序的子数组合并成一个有序的数组。

归并算法通常包含以下步骤：

  1. 分解（Divide）：将待排序的数组递归地分解为规模更小的子数组，直到每个子数组只有一个元素或为空。

  2. 解决（Conquer）：通过递归地排序子数组，将其转化为有序的子数组。这通常是通过继续将子数组进一步分解并排序的方式实现的。

  3. 合并（Merge）：将两个有序的子数组合并成一个有序的数组。该步骤的实现方式是比较两个子数组的元素，并按照顺序合并到一个新的数组中，直到所有元素都被合并。

归并排序的时间复杂度是O(nlogn)，其中n是待排序数组的长度。它的主要优点包括：

  1. 稳定性：归并排序是一种稳定的排序算法，即相等元素的相对顺序不会被改变。

  2. 适用性：归并排序适用于各种数据结构，尤其在外部排序中，它对于大规模数据的排序效果明显。

然而，归并排序也存在一些缺点：

  1. 额外空间消耗：归并排序需要额外的空间来存储临时的子数组和合并结果，这可能对内存消耗造成一定影响。

  2. 递归调用：归并排序的实现通常使用递归调用，对于大规模数据的排序可能导致递归深度增加，从而增加了额外的函数调用开销。

总结而言，归并排序是一种高效、稳定的排序算法，通过分治策略将待排序的数组分解为更小的子数组，然后逐步合并这些子数组以获得最终的有序数组。尽管归并排序需要额外的空间和函数调用开销，但它在实践中被广泛使用，特别适用于对大规模数据进行排序。

1. 排序数组

https://leetcode.cn/problems/sort-an-array/

1.1 题目要求

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

  • 1 <= nums.length <= 5 * 104
  • -5 * 104 <= nums[i] <= 5 * 104
class Solution {public int[] sortArray(int[] nums) {}
}

1.2 做题思路

不知道大家是否做过将两个有序数组合并为一个有序数组，我们的归并算法就是通过将两个数组合并为一个有序数组来实现的。而归并的思想就是就一整个数组从中间将数组分为两个数组，然后再继续将这两个数组分别从中间分开，直到将这两部分的数组分为只有一个元素的两部分数组，然后将这两个数组通过合并两个数组的操作来进行合并，合并完成之后的数组就成为了一个有序的数组，然后继续将这两个有序的数组通过合并数组的操作继续进行合并，直到将这些数组合并为一个最大的数组。
在这里插入图片描述

在这里插入图片描述

1.3 Java代码实现

class Solution {//因为每一次递归都需要创建临时的数组来存储两个数组排序之后的结果，//每次都向申请内存，速度会很慢//所以我们直接申请一个跟nums同样大小的数组int[] tmp;public int[] sortArray(int[] nums) {int n = nums.length;tmp = new int[n];mergeSort(nums,0,n -1);return nums;}private void mergeSort(int[] nums, int left, int right) {//当数组中只有一个元素或者区间不成立的时候，结束递归if(left >= right) return;int mid = left + (right - left) / 2;//先排序mid左右两边的数组，最后在将左右两边的有序数组进行合并mergeSort(nums,left,mid);mergeSort(nums,mid + 1,right);int cur1 = left,cur2 = mid + 1,i = 0;while(cur1 <= mid && cur2 <= right) {tmp[i++] = nums[cur1] < nums[cur2] ? nums[cur1++] : nums[cur2++];}//处理没到达数组结尾的数组while(cur1 <= mid) tmp[i++] = nums[cur1++];while(cur2 <= right) tmp[i++] = nums[cur2++];//将临时排序之后数组的结果更新到我们原本的数组中for(int j = left; j <= right; j++) nums[j] = tmp[j - left];}
}

在这里插入图片描述

2. 数组中逆序对

https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/description/

2.1 题目要求

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例 1:

输入: [7,5,6,4]
输出: 5

限制：

  • 0 <= 数组长度 <= 50000
class Solution {public int reversePairs(int[] nums) {}
}

2.2 做题思路

我们先来看看如何使用暴力解法来解决这个问题：用两层循环来遍历数组，i 从 0 开始，j 则从 i 的下一个位置开始，看 j 所指向的位置是否小于 i 所指的位置，如果是则逆序对总数加一。这样虽然简单，但是时间复杂度达到了 O(N^2)，是跑不过去的，那么我们就需要对暴力解法进行优化，问题就在于我们该如何优化呢？

这样想，如果我们将数组分为两个部分，先计算左边部分的数组中的所有逆序对，然后计算右边部分数组中的所有逆序对，最后在左边数组一次选择一个数字，看右边数组中是否元素能与左边数组中的那个元素构成逆序对，这样的思路其实跟暴力解法是相同的，时间复杂度都是 O(N^2)，那么当我们分别在左边数组中和右边数组中找到了符合的逆序对的话，我们是否可以将这两部分数组进行排序呢？当进行了排序之后，再分别在左边数组中依次拿元素与右边数组中的元素进行比较，假设我们按照升序的方式进行排序，当左边部分遇到比右边数组部分大的元素的话，那么左边数组部分从这个元素开始到左边部分数组结束的位置是否都大于右边数组的该元素呢？
在这里插入图片描述
如果nums[cur1] < nums[cur2] 则继续让 cur1 向右移动，直到出现逆序对的情况，这样 cur1 和 cur2 指针都不用返回，就较少了很多的重复比较，使得时间复杂度提升为
O(N*logN)。

2.3 Java代码实现

（1）升序方法

class Solution {int[] tmp;public int reversePairs(int[] nums) {int n = nums.length;tmp = new int[n];return mergeSort(nums,0,n-1);}private int mergeSort(int[] nums, int left, int right) {if(left >= right) return 0;int mid = left + (right - left) / 2;//统计逆序对的数量int ret = 0;//计算左边数组中逆序对的数量ret += mergeSort(nums,left,mid);//计算右边数组中逆序对的数量ret += mergeSort(nums,mid + 1,right);int cur1 = left, cur2 = mid + 1,i = 0;while(cur1 <= mid && cur2 <= right) {//当nums[cur1] <= nums[cur2] 的时候，只需要进行合并数组的操作if(nums[cur1] <= nums[cur2]) tmp[i++] = nums[cur1++];//当nums[cur1] > nums[cur2] 的时候，需要更新逆序对的数量，同时也需要合并数组else {ret += mid - cur1 + 1;tmp[i++] = nums[cur2++];}}while(cur1 <= mid) tmp[i++] = nums[cur1++];while(cur2 <= right) tmp[i++] = nums[cur2++];for(int j = left; j <= right; j++) nums[j] = tmp[j - left];return ret;}
}

在这里插入图片描述
（2）降序方法
我们也可以用降序排列的方式来实现归并排序，只是当使用降序的时候，需要在右边数组中统计逆序对的数量，因为当遇到 nums[cur1] > nums[cur2] 的时候，如果还是统计左边数组 mid - cur1 + 1 作为逆序对的数量的话，那么当 cur2 向后移动的时候，再遇到 nums[cur1] > nums[cur2] 的时候就会出现重复的情况，所以当我们以降序的方式排序的时候需要在右边数组中统计逆序对的数量。
在这里插入图片描述

class Solution {int[] tmp;public int reversePairs(int[] nums) {int n = nums.length;tmp = new int[n];return mergeSort(nums,0,n-1);}private int mergeSort(int[] nums, int left, int right) {if(left >= right) return 0;int mid = left + (right - left) / 2;//统计逆序对的数量int ret = 0;//计算左边数组中逆序对的数量ret += mergeSort(nums,left,mid);//计算右边数组中逆序对的数量ret += mergeSort(nums,mid + 1,right);int cur1 = left, cur2 = mid + 1,i = 0;while(cur1 <= mid && cur2 <= right) {//当nums[cur1] <= nums[cur2] 的时候，只需要进行合并数组的操作if(nums[cur1] <= nums[cur2]) tmp[i++] = nums[cur2++];//当nums[cur1] > nums[cur2] 的时候，需要更新逆序对的数量，同时也需要合并数组else {ret += right - cur2 + 1;tmp[i++] = nums[cur1++];}}while(cur1 <= mid) tmp[i++] = nums[cur1++];while(cur2 <= right) tmp[i++] = nums[cur2++];for(int j = left; j <= right; j++) nums[j] = tmp[j - left];return ret;}
}

在这里插入图片描述

3. 计算右侧小于当前元素的个数

https://leetcode.cn/problems/count-of-smaller-numbers-after-self/description/

3.1 题目要求

给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

示例 1：

输入：nums = [5,2,6,1]
输出：[2,1,1,0] 
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素

示例 2：

输入：nums = [-1]
输出：[0]

示例 3：

输入：nums = [-1,-1]
输出：[0,0]

提示：

  • 1 <= nums.length <= 105
  • -104 <= nums[i] <= 104
class Solution {public List<Integer> countSmaller(int[] nums) {}
}

3.2 做题思路

这道题目跟上面的找逆序对的数量是类似的，逆序对是找前面的元素大于后面元素的个数，而这道题是需要找到数组中每个元素的之后的小于该元素的个数，也就是说这个题目返回的是多个数，而不是一个数。那么我们在使用分冶算法的过程中该如何记住对应数字的下标呢？因为在分冶的过程中加上排序，数组中元素的位置是不断变化的，但是这道题目按顺序返回数组中对用位置右边部分大小小于该位置元素的数量，所以这道题目如何记住原本数组对应元素的下标是很重要的。

那么我们如何记住原本数组元素的对应下标呢？我们可以创建一个 index 数组，当数组进行合并排序的时候，相应的 index 数组也跟着变化，这样就能使排序后数组对应位置的 index 数组中存放的是原本数组的下标。

在这里插入图片描述

3.3 Java代码实现

class Solution {int[] ret; //该数组中存放右侧小于当前元素的个数int[] index; //存放对应元素的下标int[] tmpNums; //排序后的临时数组int[] tmpIndex; //排序后对应元素的原本下标public List<Integer> countSmaller(int[] nums) {int n = nums.length;ret = new int[n];index = new int[n];//index 数组初始化for(int i = 0; i < n; i++) index[i] = i;tmpNums = new int[n];tmpIndex = new int[n];mergerSort(nums,0,n-1);List<Integer> list = new ArrayList<>();for(int x : ret) list.add(x);return list;}private void mergerSort(int[] nums, int left, int right) {if(left >= right) return;int mid = left + (right - left) / 2;mergerSort(nums,left,mid);mergerSort(nums,mid + 1,right);int cur1 = left, cur2 = mid + 1, i = 0;//降序while(cur1 <= mid && cur2 <= right) {if(nums[cur1] <= nums[cur2]) {tmpNums[i] = nums[cur2];tmpIndex[i++] = index[cur2++];}else {//因为前面的递归中可能出现了右侧小于当前位置的数，所以需要使用+=ret[index[cur1]] += right - cur2 + 1;tmpNums[i] = nums[cur1];tmpIndex[i++] = index[cur1++];}}while(cur1 <= mid) {tmpNums[i] = nums[cur1];tmpIndex[i++] = index[cur1++];}while(cur2 <= right) {tmpNums[i] = nums[cur2];tmpIndex[i++] = index[cur2++];}for(int j = left; j <= right; j++) {nums[j] = tmpNums[j - left];index[j] = tmpIndex[j - left];}} 
}

在这里插入图片描述

4. 翻转对

https://leetcode.cn/problems/reverse-pairs/description/

4.1 题目要求

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。

你需要返回给定数组中的重要翻转对的数量。

示例 1:

输入: [1,3,2,3,1]
输出: 2

示例 2:

输入: [2,4,3,5,1]
输出: 3

注意:

  • 给定数组的长度不会超过50000。
  • 输入数组中的所有数字都在32位整数的表示范围内。
class Solution {public int reversePairs(int[] nums) {}
}

4.2 做题思路

这个题目跟前面的的两个题目都是类似的，只是这里不能在我们更新翻转对的时候就进行排序，因为翻转对的判断条件是 i < j 且 nums[i] > 2*nums[j]，根据这个判断条件，我们不能判断出 nums[i] 和 nums[j] 哪个大，所以只能在更新完翻转对之后进行归并排序，其他的步骤基本上是类似的。
在这里插入图片描述

4.3 Java代码实现

（1）升序

class Solution {int[] tmp;public int reversePairs(int[] nums) {int n = nums.length;tmp = new int[n];return mergeSort(nums,0,n-1);}private int mergeSort(int[] nums, int left, int right) {if(left >= right) return 0;int ret = 0;int mid = left + (right - left) / 2;//统计左右两部分数组中翻转对的数量ret += mergeSort(nums,left,mid);ret += mergeSort(nums,mid + 1,right);int cur1 = left, cur2 = mid + 1, i = 0;while(cur2 <= right) {//这里需要使用nums[cur1] / 2.0 而不是nums[cur2] * 2，//因为可能会导致溢出while(cur1 <= mid && nums[cur1] / 2.0 <= nums[cur2]) cur1++;if(cur1 > mid) break;ret += mid - cur1 + 1;cur2++;}//升序cur1 = left;cur2 = mid + 1;while(cur1 <= mid && cur2 <= right) {tmp[i++] = nums[cur1] < nums[cur2] ? nums[cur1++] : nums[cur2++];}while(cur1 <= mid) tmp[i++] = nums[cur1++];while(cur2 <= right) tmp[i++] = nums[cur2++];for(int j = left; j <= right; j++) nums[j] = tmp[j - left];return ret;}
}

在这里插入图片描述

（2）降序

class Solution {int[] tmp;public int reversePairs(int[] nums) {int n = nums.length;tmp = new int[n];return mergeSort(nums,0,n-1);}private int mergeSort(int[] nums, int left, int right) {if(left >= right) return 0;int ret = 0;int mid = left + (right - left) / 2;ret += mergeSort(nums,left,mid);ret += mergeSort(nums,mid + 1,right);int cur1 = left, cur2 = mid + 1, i = 0;//降序while(cur1 <= mid) {//这里cur1不动，因为cur1向后移动只会越来越小，所以让cur2向后移动while(cur2 <= right && nums[cur1] / 2.0 <= nums[cur2]) cur2++;if(cur2 > right) break;ret += right - cur2 + 1;cur1++;}cur1 = left;cur2 = mid + 1;while(cur1 <= mid && cur2 <= right) {tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur2++] : nums[cur1++];}while(cur1 <= mid) tmp[i++] = nums[cur1++];while(cur2 <= right) tmp[i++] = nums[cur2++];for(int j = left; j <= right; j++) nums[j] = tmp[j - left];return ret;}
}

在这里插入图片描述

总结

归并排序是一种高效而稳定的排序算法，它利用了分治策略，将待排序的数组分解为更小的子数组，并逐步合并这些子数组以获得最终的有序数组。

归并排序算法的核心思想是将待排序数组递归地分解为规模更小、有序的子数组，然后通过合并操作将这些子数组有序地合并成一个大的有序数组。这种分解和合并的过程直到最终合并成排序后的完整数组。

归并排序算法具有以下优点：

  1. 稳定性：归并排序是一种稳定的排序算法，即相等元素的相对顺序不会被改变。这使得它特别适用于对具有多关键字排序要求的情况。

  2. 高效性：归并排序的时间复杂度为O(nlogn)，其中n是待排序数组的长度。它具有较好的性能表现，并适用于大规模数据的排序。

此外，归并排序算法还具有一定的弹性和灵活性。它可以通过优化合并操作的实现方式，减少额外空间的消耗。此外，归并排序也适用于外部排序，可以处理存储在外部存储介质中的大规模数据。

尽管归并排序算法需要额外的空间和函数调用开销，但由于其稳定性和较好的时间复杂度，它在实际应用中被广泛采用。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/99668.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

QT DAY 4

QT DAY 4

时钟&#xff1a; #include "widget.h" #include "ui_widget.h"int hour0; int min0; int sec0; int count0; Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget) {ui->setupUi(this);this->setFixedSize(800,600);timer new …
阅读更多...
【MySql】数据库的约束

【MySql】数据库的约束

写在最前面的话 哈喽&#xff0c;宝子们&#xff0c;今天给大家带来的是MySql数据库的约束&#xff0c;约束是自动的对数据的合法性进行校验检查的一系列机制&#xff0c;目的就是为了保证数据库中能够避免被插入/修改非法的数据。因为有的时候数据库中的数据是有一定要求的&am…
阅读更多...
Android中的view绘制流程，简单理解

Android中的view绘制流程，简单理解

简单理解 Android中的View类代表用户界面中基本的构建块。一个View在屏幕中占据一个矩形区域、并且负责绘制和事件处理。View是所有widgets的基础类&#xff0c;widgets是我们通常用于创建和用户交互的组件&#xff0c;比如按钮、文本输入框等等。子类ViewGroup是所有布局&…
阅读更多...
视频汇聚/视频云存储/视频监控管理平台EasyCVR安全检查的相关问题及解决方法2.0

视频汇聚/视频云存储/视频监控管理平台EasyCVR安全检查的相关问题及解决方法2.0

开源EasyDarwin视频监控TSINGSEE青犀视频平台EasyCVR能在复杂的网络环境中&#xff0c;将分散的各类视频资源进行统一汇聚、整合、集中管理&#xff0c;在视频监控播放上&#xff0c;TSINGSEE青犀视频安防监控汇聚平台可支持1、4、9、16个画面窗口播放&#xff0c;可同时播放多…
阅读更多...
flask使用Flask-Mail实现邮件发送

flask使用Flask-Mail实现邮件发送

Flask-Mail可以实现邮件的发送&#xff0c;并且可以和 Flask 集成&#xff0c;让我们更方便地实现此功能。 1、安装 使用pip安装&#xff1a; $ pip install Flask-Mail或下载源码安装&#xff1a; $ git clone https://github.com/mattupstate/flask-mail.git $ cd flask-…
阅读更多...
ClickHouse配置Hdfs存储数据

ClickHouse配置Hdfs存储数据

文章目录 背景配置单机配置HA高可用Hdfs集群性能测试统计trait最多的10个trait term统计性状xxx minValue > 500 0000的数量结论 参考文档 背景 由于公司初始使用Hadoop这一套&#xff0c;所以希望ClickHouse也能使用Hdfs作为存储 看了下ClickHouse的文档&#xff0c;拿Hdf…
阅读更多...
HyperDock 1.8.0.10(Dock优化工具)

HyperDock 1.8.0.10(Dock优化工具)

HyperDock 是一款为 macOS 设计的实用工具&#xff0c;它提供了许多方便快捷的功能&#xff0c;使您能够更高效地管理和操作应用程序窗口。 首先&#xff0c;HyperDock 提供了类似于 Windows 7 的任务栏预览功能。当您将鼠标悬停在应用程序图标上时&#xff0c;会显示该应用程…
阅读更多...
flutter 上传图片并裁剪

flutter 上传图片并裁剪

1.首先在pubspec.yaml文件中新增依赖pub.dev image_picker: ^0.8.75 image_cropper: ^4.0.1 2.在Android的AndroidManifest.xml文件里面添加权限 <activityandroid:name"com.yalantis.ucrop.UCropActivity"android:screenOrientation"portrait"andro…
阅读更多...
Spring-mvc的参数传递与常用注解的解答及页面的跳转方式---综合案例

Spring-mvc的参数传递与常用注解的解答及页面的跳转方式---综合案例

目录 一.slf4j--日志 二.常用注解 2.1.RequestMapping 2.2.RequestParam 2.3.RequestBody 2.4.PathVariable 三.参数的传递 3.1 基础类型 3.2 复杂类型 3.3 RequestParam 3.4 PathVariable 3.5 RequestBody 3.6 增删改查 四.返回值 4.1 void 返回值 4.2 String 返…
阅读更多...
Elsaticsearch倒排索引

Elsaticsearch倒排索引

搜索引擎应该具有什么要求&#xff1f; 查询快 高效的压缩算法 快速的编码和解码速度 结果准确 BM25 TF-IDF 检索结果丰富 召回率 面向海量数据&#xff0c;如何达到搜索引擎级别的查询效率&#xff1f; 索引 帮助快速检索以数据结构为载体以文件形式落地 倒排…
阅读更多...
手把手教你写一个简单的ioc容器

手把手教你写一个简单的ioc容器

Ioc IOC&#xff08;控制反转&#xff09; 就是 依赖倒置原则的一种代码设计思路。就是把原先在代码里面需要实现的对象创建、对象之间的依赖&#xff0c;反转给容器来帮忙实现。 Spring IOC容器通过xml,注解等其它方式配置类及类之间的依赖关系&#xff0c;完成了对象的创建和…
阅读更多...
微服务-gateway基本使用

微服务-gateway基本使用

文章目录 一、前言二、gateway网关1、什么是微服务网关&#xff1f;2、微服务架构下网关的重要性2.1、没有网关2.2、有网关 3、gateway的功能4、gateway实战4.1、依赖配置4.2、添加网关配置4.3、添加网关启动类4.4、查看项目是否启动成功4.5、验证路由配置是否正确 三、总结 一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023