深度解析算法之分治（归并）

48.排序数组

题目链接

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

你必须在 不使用任何内置函数 的情况下解决问题，时间复杂度为 O(nlog(n))，并且空间复杂度尽可能小。

示例 1：

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

示例 2：

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

我们上次解决这个问题是使用快排进行解决的，那么这里是使用归并排序进行解决的

归并是什么呢？说白了就是递归

将一个数组根据中间点分成两部分，我们再从左边区间找中间点，依次这样，直到我们最后只剩下一个元素，我们依次进行返回的操作，然后进行上一层的右区间进行递归递归

当我们这一层的判断都搞定了，那么我们就进行合并两个有序数组

当我们左边和右边都排完序之后，那么我们就将这两个有序数组进行合并操作

这种非常像二叉树的后续遍历，先把左边搞好，再把右边搞好，再回到根节点

快排的过程有点类似二叉树的前序遍历

class Solution

{

public:

    vector<int> sortArray(vector<int>& nums)

    {

        mergesort(nums,0,nums.size()-1);//将这段区间进行排序，排完序直接返回就行了

        return nums;

    }

    void mergesort(vector<int>&nums,int left,int right)

    {

        if(left>=right) return;//特殊情况，如果区间不存在或者是只有一个元素的话

  

        //1.先选择中间点划分区间

        int mid=(left+right)>>1;// >> 1 是位运算中的右移操作，它将结果右移一位，相当于将结果除以2并向下取整。

        //[left,mid][mid+1,right]

        //2.将左右区间进行排序的操作

        mergesort(nums,left,mid);

        mergesort(nums,mid+1,right);

  

        //3.合并两个有序数组

        vector<int>tmp(right-left+1);//辅助数组，大小和我们的nums大小一样

        int cur1=left;//指向第一个数组

        int cur2=mid+1;//指向第二个数组

        int i=0;//辅助数组

  

        while(cur1<=mid&&cur2<=right)

        {

            tmp[i++]=nums[cur1]<=nums[cur2]?nums[cur1++]:nums[cur2++];//进行判断，如果cur1的大小小于等于cur2的话，那么就让我们的tmp[i]=nums[cur1]的值

            //就是说白了持续进行对比，谁小谁先放到tmp这个数组中去

            //i、cur1、cur2这三个指针都得往后进行移动，我们直接放在上面的那个代码中去

        }

        //到这里的话可能存在一个数组中还有数据没有移动到tmp中去，下面两句代码就是处理没有遍历完的情况

        while(cur1<=mid)tmp[i++]=nums[cur1++];//因为此时的指针还没到mid的位置，就是大小比mid小，那么我们直接将cur1这个数字中剩下的元素都放到tmp中

        while(cur2<=right)tmp[i++]=nums[cur2++];//和上面一样

  

        //还原

        for(int i=left;i<=right;i++)

        {

            nums[i]=tmp[i-left];//我们的tmp数组需要从0开始进行计数操作吗，所以我们这里使用i-left可以达到从下标0开始进行赋值操作

        }

  
  

    }

  

};

我们先找出中间点对这段数组进行划分操作，然后依次对左右区间进行排序的操作，这里就是递归调用，然后我们再合并两个数组就行了

最后我们将我们辅助数组中的值直接赋值到我们的nums中就行了

这种代码我们的时间复杂度是这样的

因为我们每次合并的时候都会创建一个辅助数组，这里的开销其实也很大的

我们可以将创建数组的这个操作放在全局的位置

class Solution

{

    vector<int>tmp;//创建辅助数组

public:

    vector<int> sortArray(vector<int>& nums)

    {

        tmp.resize(nums.size());

        mergesort(nums,0,nums.size()-1);//将这段区间进行排序，排完序直接返回就行了

        return nums;

    }

    void mergesort(vector<int>&nums,int left,int right)

    {

        if(left>=right) return;//特殊情况，如果区间不存在或者是只有一个元素的话

  

        //1.先选择中间点划分区间

        int mid=(left+right)>>1;// >> 1 是位运算中的右移操作，它将结果右移一位，相当于将结果除以2并向下取整。

        //[left,mid][mid+1,right]

        //2.将左右区间进行排序的操作

        mergesort(nums,left,mid);

        mergesort(nums,mid+1,right);

  

        //3.合并两个有序数组

        int cur1=left;//指向第一个数组

        int cur2=mid+1;//指向第二个数组

        int i=0;//辅助数组

  

        while(cur1<=mid&&cur2<=right)

        {

            tmp[i++]=nums[cur1]<=nums[cur2]?nums[cur1++]:nums[cur2++];//进行判断，如果cur1的大小小于等于cur2的话，那么就让我们的tmp[i]=nums[cur1]的值

            //就是说白了持续进行对比，谁小谁先放到tmp这个数组中去

            //i、cur1、cur2这三个指针都得往后进行移动，我们直接放在上面的那个代码中去

        }

        //到这里的话可能存在一个数组中还有数据没有移动到tmp中去，下面两句代码就是处理没有遍历完的情况

        while(cur1<=mid)tmp[i++]=nums[cur1++];//因为此时的指针还没到mid的位置，就是大小比mid小，那么我们直接将cur1这个数字中剩下的元素都放到tmp中

        while(cur2<=right)tmp[i++]=nums[cur2++];//和上面一样

  

        //还原

        for(int i=left;i<=right;i++)

        {

            nums[i]=tmp[i-left];//我们的tmp数组需要从0开始进行计数操作吗，所以我们这里使用i-left可以达到从下标0开始进行赋值操作

        }

  
  

    }

  

};

这里我们可以看看时间开销

如果在递归中需要创建空间的话，那么我们就将这个操作放在全局上

49.数组中的逆序对

题目链接

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

输入一个数组，求出这个数组中的逆序对的总数。

数据范围

给定数组的长度 [0,100][0,100]。

样例

输入：[1,2,3,4,5,6,0]

输出：6

暴力解法：暴力枚举

两层for循环就能暴力出所有的情况，但是会超时的

我们求出一个中心点，将整个数组分成两段，分别进行判断 ，递归进行求

利用归并排序解决该问题

逆序对就是一个数之前有多少个数比自身大，那么就有多少组逆序对

那么我们盯着cur2这个区域看就行了
因为我们这里经过了排序了，所以两个区域都是升序的，

如果nums[cur1]<=nums[cur2]的话，那么就让cur1++

如果nums[cur1]>nums[cur2]的话，因为区域是升序的吗，所以当前cur1后面的都是比cur2大的数字，所以我们就找到了一堆的逆序数，所以我们的逆序数总和就加上了mid-cur1+1

所以这个题利用归并排序的话时间复杂度就是nlogn

我们这个题是升序的，如果是降序的话这个题怎么做呢？

如果nums[cur1]>nums[cur2]的话，那么我们就统计cur1前面的区域，然后我们将cur1++，但是如果此时的nums[cur1]>nums[cur2]，那么我们就会出现重复计算的问题了

如果我们将原先的策略改成：找出某个数之后，有多少个数比较小，然后我们此时就可以利用到了这个降序操作了

如果我们当前cur1大于cur2的话，因为这个是降序的，所以cur2后面的都比cur2小，所以我们找到比cur1小的数就行了，那么cur2后面一大堆比cur1小的，统计完当前数中有多少个数比cur1小的，然后我们的cur1进行右移操作

下面是数组为升序的版本

class Solution
{
    int tmp[999999];//创建一个辅助数组进行数组合并的
public:
    int inversePairs(vector<int>& nums)
    {
        return mergeSort(nums,0,nums.size()-1);//将0~n-1这段区间的逆序对都找到
        
    }
    int mergeSort(vector<int>&nums,int left,int right)
    {
        if(left>=right) return 0;//处理特殊情况，这个区间没有逆序对或者是 只存在一个元素的话
        
        int ret=0;//记录最终的结果
        //1.找一个中间点
        int mid=(right+left)>>1;
        //划分为下面的两个区间了
        //[left,mid][mid+1,right]
        
        //2.左边的逆序对的个数+排序+右边的逆序对的个数+排序
        ret+=mergeSort(nums,left,mid);
        ret+=mergeSort(nums,mid+1,right);
        
        //3.一左一右的情况
        int cur1=left,cur2=mid+1,i=0;
        while(cur1<=mid&&cur2<=right)
        {
            if(nums[cur1]<=nums[cur2]) tmp[i++]=nums[cur1++];
            else //这个就是cur1的数大于cur2的数
            {
                ret+=mid-cur1+1;
                tmp[i++]=nums[cur2++];//将小的放进去
            }
        }
        //4.处理下排序,将剩下的元素放进去
        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;
    }
};

归并排序的第一步是递归地将数组拆分成越来越小的子数组，直到每个子数组只有一个元素为止。这个过程是通过 mergeSort(nums, left, mid) 和 mergeSort(nums, mid + 1, right) 完成的。每次递归都会找到数组的中间点 mid，然后对左右两部分递归调用 mergeSort。

在归并的过程中，我们将左右两个子数组合并成一个已排序的数组。在这个过程中，如果左侧的某个元素大于右侧的某个元素，那么这些元素就构成了逆序对。

剩余元素处理：

如果在合并的过程中，某一侧的数组已经处理完了，而另一侧仍然有元素剩余，这时剩下的元素已经是有序的，因此可以直接将它们放入到 tmp 数组中，不需要做任何比较。

将排序后的元素放回原数组：

合并完成后，我们将 tmp 数组中的元素复制回 nums 数组，这样在上层递归中会使用到最新排序好的数组。

下面是降序的代码

class Solution
{
    int tmp[999999];//创建一个辅助数组进行数组合并的
public:
    int inversePairs(vector<int>& nums)
    {
        return mergeSort(nums,0,nums.size()-1);//将0~n-1这段区间的逆序对都找到
        
    }
    int mergeSort(vector<int>&nums,int left,int right)
    {
        if(left>=right) return 0;//处理特殊情况，这个区间没有逆序对或者是 只存在一个元素的话
        
        int ret=0;//记录最终的结果
        //1.找一个中间点
        int mid=(right+left)>>1;
        //划分为下面的两个区间了
        //[left,mid][mid+1,right]
        
        //2.左边的逆序对的个数+排序+右边的逆序对的个数+排序
        ret+=mergeSort(nums,left,mid);
        ret+=mergeSort(nums,mid+1,right);
        
        //3.一左一右的情况
        int cur1=left,cur2=mid+1,i=0;
        while(cur1<=mid&&cur2<=right)
        {
            if(nums[cur1]<=nums[cur2]) tmp[i++]=nums[cur2++];
            else 
            {
                ret+=right-cur2+1;
                tmp[i++]=nums[cur1++];
            }
        }
        //4.处理下排序,将剩下的元素放进去
        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;
    }
};

改动的代码在这里

50.计算右侧⼩于当前元素的个数

题目链接

给你一个整数数组 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]

有点像我们的逆序对

使用归并排序

我们需要快速求出当前元素右边有多少个元素比当前元素小

我们这里使用策略二：当前元素右边元素有多少个比我小

如果nums[cur1]<=nums[cur2]的话，那么我们的cur2得往右边进行挪动了

但是如果nums[cur1]>nums[cur2]的话，那么我们就得将nums[cur1]在统计数的那个数组中的对应的位置加上我们有多少个小于cur2的位置的数了，所以我们得找到cur1的原始下标了，我的思路是使用hash，但是如果出现了重复元素的话就不好搞了

我们再创建一个数组，存的是我们原始的下标，一起进行绑定移动就行了

我们这里是需要创建两个辅助数组的，一个是nums合并的辅助数组

一个是原始下标的辅助数组

class Solution

{

    vector<int>ret;

    vector<int>index;//记录当前元素的原始下标

    int tmpNums[500010];//nums的辅助数组

    int tmpIndex[500010];//index的辅助数组

public:

    vector<int> countSmaller(vector<int>& nums)

    {

        int n=nums.size();

        ret.resize(n);

        index.resize(n);

  

        //初始化index数组

        for(int i=0;i<n;i++)

        {

            index[i]=i;

        }

        mergerSort(nums,0,n-1);

        return ret;

    }

    void mergerSort(vector<int>&nums,int left,int right)

    {

        //先处理边界情况

        if(left>=right) return ;//要么这个数组只有一个元素，要么就是没有元素

  

        //1.根据中间元素划分区间

        int mid=(right+left)>>1;

        //[left,mid][mid+1,right]

  

        //2.先处理左右两部分

        mergerSort(nums,left,mid);

        mergerSort(nums,mid+1,right);

  

        //3.处理一左一右的情况

        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//nums[cur1]>nums[cur2]

            {

                //index[cur2]就是cur2当前的下标

                ret[index[cur1]]+=right-cur2+1;//重点，先找到原始位置的下标,我们这里统计的是cur1位置后面的数有多少个比cur1小

                tmpNums[i]=nums[cur1];

                tmpIndex[i++]=index[cur1++];

            }

        }

  

        //3.处理排序剩下的排序过程

        while(cur1<=mid) //说明我们的cur1还有预留的数据，那么我们将剩下的数据全部放到我们的辅助数组中去

        {

            tmpNums[i]=nums[cur1];

            tmpIndex[i++]=index[cur1++];

        }

        while(cur2<=right) //说明我们的cur1还有预留的数据，那么我们将剩下的数据全部放到我们的辅助数组中去

        {

            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];

        }

  
  

    }

};

求当前位置的右边有多少个数比cur1小的。所以我们这里是降序的，将大的元素先进行移动到辅助数组中去

51.翻转对

题目链接

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

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

示例 1:

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

示例 2:

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

找两个数，前面的数是大于后面的那个数的两倍的

策略一：计算当前元素后面，有多少元素的两倍比我小 降序

我们发现cur2位置的两倍的大小比cur1小，那么cur2后面的数字的两别都比cur1小

计算翻转对->同向双指针

策略二：计算当前元素之前，有多少元素的一半比我大 升序

我们这里移动cur1，如果cur1的一半比cur2小的话，那么cur1右移

当我们发现cur1的一半比cur2大的话，那么cur1后面的一半都比cur2大

下面是降序的代码

class Solution

{

    int tmp[50010];//辅助数组，帮助我们合并排序

public:

    int reversePairs(vector<int>& nums)

    {

        return mergeSort(nums,0,nums.size()-1);

    }

  

    int mergeSort(vector<int>&nums,int left,int right)

    {

        if(left>=right) return 0;//处理异常情况

  

        int ret=0;  

        //1.先根据中间元素划分区间

        int mid=(right+left)>>1;

        //[left,mid][mid+1,right]

  

        //2.先计算左右两侧的翻转对

        ret+=mergeSort(nums,left,mid);

        ret+=mergeSort(nums,mid+1,right);

  

        //3.先计算翻转对的数量

        int cur1=left,cur2=mid+1,i=left;

        while(cur1<=mid)//降序

        {

            while(cur2<=right &&nums[cur2]>=nums[cur1]/2.0) cur2++;//向后进行移动，直到找到合适的位置

            if(cur2>right) break;//如果满足了越界的情况了，那么我们直接break就行了

            //出了循环就说明我们找到对应的位置了

            ret+=right-cur2+1;

            cur1++;//cur1向后移动

        }

        //4.合并两个有序数组

        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++];

  

        //5.还原

        for(int j=left;j<=right;j++)

        {

            nums[j]=tmp[j];

        }

        return ret;

    }

};

我们先根据中间元素划分区间，然后计算左右两侧的翻转对，这个就是递归调用函数

然后计算翻转对的数量，然后合并两个有序数组，最后就是还原了

。

这里计算翻转对的数量，我们让我们的cur1不动，cur一直往后移动，直到遇到了满足条件的，就是nums[cur2]>=nums[cur1]/2.0的话，那么我们就将cur2后面这段区间进行累加到ret中去，然后再去移动cur1进行下一组的判断，循环结束之后，我们的翻转对的数量就计算出来了

这个时候我们得将当前的这段和别的段进行合并，就是合并两个有序数组的操作，直接合并在tmp这个辅助数组中，合并完成之后可能会有一组数组还有剩余的数据，我们将这些数据放到我们的tmp中去

最后我们需要将原先的数组进行还原操作
为什么需要进行还原操作？

在递归过程中，原始数组 nums 的数据会被拆分成许多子数组，且每个子数组都在递归过程中经过合并操作。在合并过程中，我们将排好序的子数组的元素合并到辅助数组 tmp 中。如果不还原回来，nums 数组就无法保持正确的排序顺序，也无法准确地反映最终的排序结果

我们使用升序的代码进行解决问题

升序就是找当前元素之前有多少个数比我大， 所以此时固定的就是cur2了

class Solution

{

    int tmp[50010];//辅助数组，帮助我们合并排序

public:

    int reversePairs(vector<int>& nums)

    {

        return mergeSort(nums,0,nums.size()-1);

    }

  

    int mergeSort(vector<int>&nums,int left,int right)

    {

        if(left>=right) return 0;//处理异常情况

  

        int ret=0;  

        //1.先根据中间元素划分区间

        int mid=(right+left)>>1;

        //[left,mid][mid+1,right]

  

        //2.先计算左右两侧的翻转对（递归调用操作）

        ret+=mergeSort(nums,left,mid);

        ret+=mergeSort(nums,mid+1,right);

  

        //3.先计算翻转对的数量

        int cur1=left,cur2=mid+1,i=left;

        while(cur2<=right)//升序

        {

            while(cur1<=mid &&nums[cur2]>=nums[cur1]/2.0) cur1++;//向后进行移动，直到找到合适的位置

            if(cur1>mid) break;//如果满足了越界的情况了，那么我们直接break就行了

            //出了循环就说明我们找到对应的位置了

            ret+=mid-cur1+1;

            cur2++;//cur1向后移动

        }

        //4.合并两个有序数组

        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++];

  

        //5.还原

        for(int j=left;j<=right;j++)

        {

            nums[j]=tmp[j];

        }

        return ret;

    }

};