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

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

示例:
输入: [5,2,6,1]
输出: [2,1,1,0]
解释:
5 的右侧有 2 个更小的元素 (2 和 1).
2 的右侧仅有 1 个更小的元素 (1).
6 的右侧有 1 个更小的元素 (1).
1 的右侧有 0 个更小的元素.

方法1：直接暴力解法，超时
主要思路：
（1）直接对每个当前的元素，遍历其后面的元素中小于该元素的数量，直接超时；

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        if(nums.size()==1)
            return vector<int>(1,0);
        //int size_nums=nums.size();
        int cur_count=0;
        vector<int> count(nums.size(),0);
        for(int i=nums.size()-2;i>=0;--i){
            for(int j=nums.size()-1;j>i;--j){
                if(nums[i]>nums[j])
                    ++cur_count;
            }
            count[i]=cur_count;
            cur_count=0;
        }
        return count;
    }
};

方法2：使用归并排序
主要思路：
（1）在归并排序的过程中，实现统计一个元素的右侧有多少个小于该元素的值的元素个数；
（2）归并排序是稳定排序

class Solution {
public:

	//归并排序的合并，既使用这个函数的两个段，都是有序的
    void merge(vector<pair<int,int>>& nums_index,vector<int>& res,int left,int mid,int right){
        int i=left;
        int j=mid+1;
        int k=left;
        vector<pair<int,int>> nums_sort;
		//以下三个while是合并有序的两个段
        while(i<=mid&&j<=right){
            if(nums_index[i].first<=nums_index[j].first){
            	//这个是本题的关键，既左侧的一个值大于右侧的值的个数
            	//既元素nums_index[i].first在原数组的位置是nums_index[i].second，在该位置后侧的小于该数的数量，当前段有j-mid-1个
                res[nums_index[i].second]+=j-mid-1;
                nums_sort.push_back(nums_index[i++]);
            }
            else{
                nums_sort.push_back(nums_index[j++]);
            }
        }
        
        while(i<=mid){
            res[nums_index[i].second]+=j-mid-1;
            nums_sort.push_back(nums_index[i++]);
        }

        while(j<=right){
            nums_sort.push_back(nums_index[j++]);
        }
		//将排序后的元素放回原数组
        for(int m=0,n=left;m<nums_sort.size();++m,++n){
            nums_index[n]=nums_sort[m];
        }
    }
	
	//归并排序的分割
    void merge_sort(vector<pair<int,int>>& nums_index,vector<int>& res,int left,int right){
    	//分割的终止条件，既只剩余一个元素，或没有元素
        if(left>=right)
            return;
        //找出中点位置，进行分割
        int mid=left+(right-left)/2;
        //对两段接着进行分割
        merge_sort(nums_index,res,left,mid);
        merge_sort(nums_index,res,mid+1,right);
        //将分割后，有序的段进行合并
        merge(nums_index,res,left,mid,right);
    }

    vector<int> countSmaller(vector<int>& nums) {
        if(nums.empty())
            return vector<int>();
		//存储结果
        vector<int> res(nums.size(),0);
        //将原数组和其对应的索引进行绑定，既组成pair，便于后面归并排序的过程中，实现直接找到对应的数字在原数组中的位置
        vector<pair<int,int>> nums_index(nums.size());
        for(int i=0;i<nums.size();++i){
            nums_index[i].first=nums[i];
            nums_index[i].second=i;
        }
		//归并排序
        merge_sort(nums_index,res,0,nums.size()-1);

        return res;
    }
};