算法：归并排序

归并排序不仅仅是一种排序方式，其包含区间合并的思想，某种程度上与线段树、树状数组有类似之处，这里列举两道可以使用归并排序解决的算法题目。

327. 区间和的个数

给你一个整数数组 nums 以及两个整数 lower 和 upper 。求数组中，值位于范围 [lower, upper] （包含 lower 和 upper）之内的 区间和的个数 。

区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。
327. 区间和的个数

class Solution:
    def countRangeSum(self, nums, lower: int, upper: int) -> int:
        n = len(nums)
        prefixs = [0]*n
        t = 0
        ans = 0
        for i in range(n):
            t += nums[i]
            prefixs[i] = t
            if lower<= t<= upper:
                ans += 1
        return ans + self.mergesort(prefixs, lower, upper)
        
    def mergesort(self, prefixs, lower, upper):
        if len(prefixs) < 2:
            return 0
        mid = len(prefixs)//2
        L,R = prefixs[:mid], prefixs[mid:]
        ans = 0
        ans += self.mergesort(L, lower, upper)
        ans += self.mergesort(R, lower, upper)
        left,right=0,0
        for i in range(len(L)):
            while left < len(R) and R[left] - L[i] < lower:
                left += 1
            while right < len(R) and R[right] - L[i] <= upper:
                right += 1
            if right > left:
                ans += right - left
        i,j,k=0,0,0
        while i<len(L) and j<len(R):
            if L[i]<=R[j]:
                prefixs[k] = L[i]
                i += 1
            else:
                prefixs[k] = R[j]
                j += 1
            k += 1
            
        while i<len(L):
            prefixs[k] = L[i]
            i += 1
            k += 1
        while j<len(R):
            prefixs[k] = R[j]
            j += 1
            k += 1
        
        return ans

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

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

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

class Solution:
    def countSmaller(self, nums: List[int]) -> List[int]:
        n = len(nums)
        indexs = [i for i in range(n)]
        ans = [0]*n
        self.mergesort(nums, indexs, ans)
        l = [0]*n
        for i in range(n):
            l[indexs[i]] = ans[i]
        return l
    
    def mergesort(self, nums, indexs, ans):
        if len(nums) < 2:
            return 
        mid = len(nums)//2
        L,R = nums[:mid], nums[mid:]
        iL,iR = indexs[:mid], indexs[mid:]
        aL, aR = ans[:mid], ans[mid:]
        self.mergesort(L, iL, aL)
        self.mergesort(R, iR, aR)
        i,j,k=0,0,0
        while i<len(L) and j<len(R):
            if L[i] <= R[j]:
                nums[k] = L[i]
                indexs[k] = iL[i]
                ans[k] = aL[i] + j
                i += 1
            else:
                nums[k] = R[j]
                indexs[k] = iR[j]
                ans[k] = aR[j]
                j += 1
            k += 1
        while i<len(L):
            nums[k] = L[i]
            indexs[k] = iL[i]
            ans[k] = aL[i] + j
            i += 1
            k += 1
        while j<len(R):
            nums[k] = R[j]
            indexs[k] = iR[j]
            ans[k] = aR[j]
            j += 1
            k += 1
        return