算法---分治(归并排序)

已于 2024-04-05 10:12:00 修改
阅读量852 收藏 12
点赞数 21
分类专栏： 算法 Java 文章标签： 算法 java
于 2024-04-05 10:09:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60963435/article/details/137380702
版权
Java 同时被 2 个专栏收录
86 篇文章 0 订阅
订阅专栏
算法
26 篇文章 0 订阅
订阅专栏

在这里插入图片描述

T04BF

👋专栏: 算法|JAVA|MySQL|C语言

🫵 小比特 大梦想

此篇文章与大家分享分治算法关于归并排序的专题
对于归并排序在我个人主页专栏 <排序> 有详细的介绍
如果有不足的或者错误的请您指出!

1.归并排序

题目: 排序数组

1.1解析

关于归并排序的解析在我的个人主页<排序>专栏有详细的解释,理解归并排序对本专题的其他题目格外重要,一定要先理解归并排序的原理
本文直接画图说明:
在这里插入图片描述

1.2题解

public class Test4 {
        int[] tmp;//将tmp数组设置为类属性时间复杂度更低
    public int[] sortArray(int[] nums) {
        tmp = new int[nums.length];
        mergeSort(nums,0,nums.length-1);
        return nums;
    }
    private void mergeSort(int[] nums,int left,int right){
        if(left >= right){
            return;
        }
        int mid = left + (right-left)/2;
        mergeSort(nums,left,mid);
        mergeSort(nums,mid+1,right);

        int i = 0;
        int cur1 = left;
        int 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];
        }
    }
}

2.数组中的逆序对

题目:数组中的逆序对

2.1解析:

如果我们通过暴力解法,就是两个两个枚举,但是时间复杂度太高了,在本题会超时
我们转变一下思路:
在这里插入图片描述
如果我们把数组划分维如图所示的两段区间,假设左区间的逆序对的数量为a,右边的逆序对的数量为b,再加上枚举左边一个右边一个元素的所有逆序对的情况为c,那么总逆序对的情况就是a + b + c;而左边区间和右边区间又各自可以分成两段区间…
举个具体例子:
在这里插入图片描述
如图所示,我们用count来记录逆序对的个数,那么最后一层9 和 7,就是1组逆序对,count = 1; 9 7 和 5,可以组成 (9,5)和 (7,5),那么count = 3;
4和6不能组成逆序对;9 7 5 和 4 6,可以组成(9,4),(9,6),(7,4),(7,6),(5,4) ,那么count = 8
而上述每次分解成两段区间的过程不就是我们归并排序的分解过程嘛??
再者说,好像我们这样子分,到头来还是需要一一枚举,好像时间复杂度并没有很大的提示.但是我们实际上会发现一个细节:
我们在一一枚举的过程中并不关心左区间元素的顺序,也不关心右区间元素的顺序,我们每次只需要关心相对于左边的某个元素,在右边有多少个比这个元素小即可
那么我们就可以利用归并排序,将左右区间排序好
在这里插入图片描述
假设这是我们某段已经分别排好序的左右区间,排完序后我们找逆序对的时间复杂度就很低了
我们用变量cur2来遍历右区间,用变量cur1来遍历左区间
那么在定住cur2的时候,我们只需在左边从左到右找到第一个比2大的,就是3,那么,在左区间内3以后的所有数字,都可以和右区间的2组成逆序对,这样我们一下子就找出很多逆序对,不再需要一一枚举;接下来cur2++,但是cur1不需要回头重新从1开始遍历,因为我们的区间是递增的,而1 < 2,1就必然小于3,这就是排序给我们带来的很多好处
而当我们回顾一下归并排序的过程:我们也是用变量cur2来遍历右区间,用变量cur1来遍历左区间,当nums[cur1] <= nums[cur2]的时候,cur1++;反之cur2++,这不就恰好和我们上面分析的过程一模一样嘛???
因此我们只需要将上面的找逆序对的过程穿插在归并排序中间即可!不会给原归并排序带来时间复杂度的增加,因此时间复杂度还是O(N logN)!

理解完上面后,我们来拓展一个点
我们上面的数组是递增的,但是如果是递减呢??
在这里插入图片描述
那么此时我们应该是定住左边的元素,在右边找到第一个比这个元素小的,那么找到的这个元素之后的所有元素,都能和左边这个元素组成逆序对

2.2题解:

class Solution {
    private  int count = 0;
    private  int[] tmp;
    public  int reversePairs(int[] record) {
        tmp = new int[record.length];
        mergeSort(record,0,record.length-1);
        return count;
    }
    private  void mergeSort(int[] record,int left,int right){
        if(left >= right){
            return;
        }
        int mid = left + (right-left)/2;
        mergeSort(record,left,mid);
        mergeSort(record,mid+1,right);

        int cur1 = left;
        int cur2 = mid+1;
        int k = 0;
        while(cur1 <= mid && cur2 <= right){
            if(record[cur1] > record[cur2]){
                tmp[k++] = record[cur2++];
                count += mid - cur1 + 1;
            }else{
                tmp[k++] = record[cur1++];
            }
        }
        while(cur1 <= mid){
            tmp[k++] = record[cur1++];
        }
        while(cur2 <= right){
            tmp[k++] = record[cur2++];
        }

        for(int i = left; i <= right; i++){
            record[i] = tmp[i-left];
        }
    }
}

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

题目:计算右侧小于当前元素的个数

3.1解析

实际上和我们上一道题的原理是一模一样的,但是这道题要我们返回的是数组就给我们带来了一定的难度
即题目要求我们返回的是数组,数组中存储的是给定数组对应元素的右侧小于当前元素的个数,而由于我们的原数组在归并排序中是一直在变的
解决方法就是哈希思想,但是我们采用哈希表,因为数组中可能会存在重复元素;
我们可以构建一个index数组,用来映射给定数组的下标,.当给定数组变了的时候,我们的index也要跟着变

3.2 题解

class Solution {
    int[] ret;
    int[] tmp;
    int[] tmpIndex;
    int[] index;
    public List<Integer> countSmaller(int[] nums) {
        ret = new int[nums.length];
        tmp = new int[nums.length];
        tmpIndex = new int[nums.length];
        index = new int[nums.length];
        for(int i = 0; i < index.length; i++){
            index[i] = i;
        }
        mergeSort(nums,0,nums.length-1);
        List<Integer> list = new ArrayList<>();
        for(int x : ret){
            list.add(x);
        }
        return list;
    }
    private void mergeSort(int[] nums,int left,int right){
        if(left >= right){
            return;
        }
        int mid = left + (right - left)/2;
        mergeSort(nums,left,mid);
        mergeSort(nums,mid+1,right);

        int cur1 = left;
        int cur2 = mid + 1;
        int k = 0;
        while(cur1 <= mid && cur2 <= right){
            if(nums[cur2] >= nums[cur1]){
                tmp[k] = nums[cur2];
                tmpIndex[k++] = index[cur2++];

            }else{
                ret[index[cur1]] += right - cur2 + 1;
                tmp[k] = nums[cur1];
                tmpIndex[k++] = index[cur1++];
            }
        }
        while (cur1 <= mid){
            tmp[k] = nums[cur1];
            tmpIndex[k++] = index[cur1++];
        }
        while(cur2 <= right){
            tmp[k] = nums[cur2];
            tmpIndex[k++] = index[cur2++];
        }

        for(int i = left; i <= right; i++){
            nums[i] = tmp[i-left];
            index[i] = tmpIndex[i-left];
        }
    }
}

4.翻转对

题目:翻转对

4.1解析

大体思路还是和我们前两题的思路是一样的,但是有一点特别的就是,.我们前两道题,无论是找逆序对还是找比当前元素小的个数,实际上都是单纯的两个数比大小,恰好和归并排序的过程吻合
但是我们这道题要比较的是两倍的关系,因此我们需要"合并"两次,第一次合并实际上并不是真正的合并,而是判断进行比较;第二次才是真正的合并

4.2题解

class Solution {
    int[] tmp;
    int count = 0;
    public int reversePairs(int[] nums) {
        tmp = new int[nums.length];
        merseSort(nums,0,nums.length-1);
        return count;
    }

    private void merseSort(int[] nums,int left,int right){
        if(left >= right){
            return;
        }
        int mid = left + (right - left) / 2;
        merseSort(nums,left,mid);
        merseSort(nums,mid+1,right);
        int cur1 = left;
        int cur2 = mid + 1;

        while(cur1 <= mid && cur2 <= right){
            while(cur2 <= right && nums[cur1] / 2.0 <= nums[cur2]){
                cur2++;
            }
            count += right - cur2 + 1;
            cur1++;
        }
        cur1 = left;
        cur2 = mid+1;
        int k = 0;
        while(cur1 <= mid && cur2 <= right){
            tmp[k++] = nums[cur1] > nums[cur2] ? nums[cur1++] : nums[cur2++];
        }
        while(cur1 <= mid){
            tmp[k++] = nums[cur1++];
        }
        while(cur2 <= right){
            tmp[k++] = nums[cur2++];
        }
        for(int i = left; i <= right; i++){
            nums[i] = tmp[i-left];
        }
    }
}

感谢您的访问!!期待您的关注!!!

在这里插入图片描述

T04BF

🫵 小比特 大梦想
t04bf
关注
专栏目录
算法-归并排序-分治法
qq_42575647的博客
05-19 742
归并分类法简介 归并分类算法利用分治法的思想，将要排序的数据二分为2组、又对这2组继续二分为4组…直至每组只有1到2个数据，这时通过比较进行排序。之后再将排序后的各组数据通过比较不断合并为更大的数组，直至最后合成为初始的数组。 算法流程或算法设计思想。 利用分治法思想，具体流程： 1. 使用递归思想，将每组数据不断二分为两组，直至无法继续二分。 2. 对完成分组的数据进行排序，排序后按原路线...
详解Java常用排序算法-归并排序
08-26
归并排序是一种分治思想的排序算法，其基本思想是将待排序的数组分成若干个子序列，每个子序列都是有序的，然后再将子序列合并成一个有序的数组。这种算法的时间复杂度为O(n log n)，空间复杂度为O(n)。 在Java中，...
分治算法-归并排序
m0_49015921的博客
01-02 599
本题用到了递归思想，如看不懂可以先去看汉诺塔问题。 题目是这样的输入数量n，然后输入n个数对其进行排序。 #include<iostream> using namespace std; void Merge(int a[],int left,int mid,int right){ int *b = new int[right-left+1]; int i= left,j=mid+1,k=0; while(i<=mid && j<=right){ i
排序算法 - 归并排序详解
张大安的博客
05-09 4656
基本介绍 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 基本思想 将序列中待排序数字分为若干组，最终每个数字分为一组。（默认长度为1的序列是有序的） 将若干个组两两合并，保证合并后的组是有序的。（俩个子序列头部进行比较大小） 重复第二步操作直到只剩下一组，排序完成。 归并排序思想示
排序算法-归并排序(C语言)
菜鸟的博客
10-14 960
归并排序是一种基于分治思想的排序算法，归并排序主要有两个操作，分别是归和并这两种操作，归就是递归，并就是合并的意思。归并排序一共有两种实现方法，一种是自下而上递归，一种是自上而下递归。
分治法--归并排序算法
m0_66279156的博客
03-02 1162
1.归并排序（Merge Sort)算法完全依照了分治模式 -分解：将n个元素分成n/2个元素的子序列 -解决：将两个子序列递归的排序 -合并：合并两个已经排好序的子序列以得到排序的结果 2.和快排不同的是 -归并的分解较为随意 -重点是合并 package 分治法; import java.util.Arrays; public class 归并排序 { public static void main(String[] args) { int []arr=new
算法-从归并排序到归并分治
2301_81486828的博客
05-29 910
归并排序是Merge sort）是一种有效、稳定的排序算法，它采用了分治法（Divide and Conquer）的典型应用,何为分治?即把多个事件分为两个或者多个子问题来解决(其实是一种递归寻找子问题的思路)归并分支的思想原理 : 在思考一个问题在大范围上的答案, 是否等于, 左部分的答案 + 右部分的答案 + 跨越左右的答案在计算跨越左右的答案的时候, 我们要思考如果加上左右都有序的这个条件, 会不会获得计算的便利性如果满足上述的两点, 那我们的这个题大概率是通过归并分治的思路去解决。
分治算法－归并排序（C++）
了解➔熟悉➔掌握➔精通
01-09 401
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请轻击http://www.captainbed.net /* * 分治算法－归并排序。 * * MergeSort.cpp - by LiveEveryDay */ #include <iostream> using namespace std; void merge(int a[], int n, int low, int mid, int high) { int t[n];
分治算法①-使用分治算法实现归并排序-python
灰灰老师
09-25 1825
归并排序是建立在归并操作上的一种有效的排序算法,该算法采用经典的分治策略（分治法将问题分（分解）成一些小的问题然后递归求解，而治（合并）的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序，若将两个有序表合并成一个有序表，称为二路归并。
排序算法-归并排序
qq_36944952的博客
12-30 4272
排序算法-归并排序 算法思想 归并：将两个或者两个以上的有序表组合成一个新的有序表的过程。假定待排序表中含有n个记录，则可以看成是n个有序的子表，每个子表的长度为1，然后两两归并，得到⌈n/2⌉\lceil n/2 \rceil⌈n/2⌉个长度为2或1的有序表；再两两归并，如此一直重复，直到合并成一个长度为n的有序表为止，这种排序方法称为2路归并排序。 2路归并排序的过程如下图所示。 从归并的过程不难看出，其代码实现可以基于分治思想递归实现。其基本问题是如何实现两个有序序列的归并操作，该操作可以通过使用辅
排序算法---归并排序
sy4331的博客
03-20 2060
1. 归并操作 归并排序是在归并操作上实现的。先了解一下归并操作的原理。 归并操作：将两个有序数组合并为一个新的有序数组。 如有序数组A=[1, 4, 6], B=[2, 4, 5]，将其进行合并。设置变量下标i和j分别表示数组A和B的下标。遍历完数组A和B，最终合并后数组为C。 若A[i] <= B[j]，则将A[i]保存到数组C，并将i++； 若A[i] > B[j]，则将B[j]保存到数组C，并将j++； 归并操作的具体实现如下： void Merge(int *piAr
排序算法-归并排序详细讲解（MergeSort）
12-25
归并排序（Merge Sort）是一种基于分治策略的高效排序算法，它的主要思想是将大问题分解成小问题，然后逐个解决小问题，最后再将解决好的小问题合并成解决大问题的答案。这个过程可以形象地比喻为将两个已排序的列表...
算法-数据结构和算法-14-归并排序.rar
09-16
归并排序是一种高效的排序算法，基于分治策略。在计算机科学中，数据结构和算法是核心部分，因为它们直接影响程序的效率和性能。归并排序是排序算法中的一个重要概念，尤其在处理大量数据时，其稳定性及平均时间...
算法-理论基础- 排序- 归并排序（包含源程序）.rar
09-16
归并排序是一种经典的排序算法，基于分治策略。在计算机科学中，分治法是一种将大问题分解为小问题来解决的方法。归并排序利用这一思想，将一个大数组拆分成两个或更多个小数组，分别对这些小数组进行排序，然后将...
基于python的排序算法-归并排序Merge Sort
06-25
归并排序（Merge Sort）是一种高效的、稳定的排序算法，它采用了分治法（Divide and Conquer）的设计理念。在Python中实现归并排序，我们可以将一个大问题分解为两个或多个相同或相似的小问题，然后分别解决这些小...
算法基础-链表
August的专栏
11-05 219
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 328
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 305
Leetcode 160. 相交链表
二叉树(一)
m0_74340589的博客
11-05 431
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
C语言分治法归并排序算法实现与应用
资源摘要信息:"C语言用分治法实现数组归并排序算法实现" 知识点一：分治法的基本概念 分治法（Divide and Conquer）是一种算法设计方法，其核心思想是将一个难以直接解决的大问题，划分成若干个小问题，递归地解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值