【排序算法系列】1. 归并排序

知识点：归并排序

归并排序思路：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用 分治法（Divide and Conquer） 的一个非常典型的应用。

归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列

排序代码：

def merge(nums):
    if len(nums)>1:
        mid=len(nums)//2
        left=nums[:mid]
        right=nums[mid:]
        merge(left)
        merge(right)
        i=0;j=0;k=0
        while i<len(left) and j<len(right):
            if left[i]<right[j]:
                nums[k]=left[i]
                i+=1
            else:
                nums[k]=right[j]
                j+=1
            k+=1
        while i<len(left):
            nums[k]=left[i]
            i+=1
            k+=1
        while j<len(right):
            nums[k]=right[j]
            j+=1
            k+=1
#测试代码
nums=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]
merge(nums)
print(nums)

运行结果：

归并排序思路的应用：

题目描述：

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007。例如，在数组{7，5，6，4}中，一共存在5个逆序对，分别是（7，6）、（7，5）、（7，4）、（5，4）、（6，4）.

思路：

将数组分解成成两个长度为2的子数组，再把这两个子数组分别拆分为两个长度为1的子数组。接下来一边合并相邻的子数组，一边统计逆序对的数目。

这个过程，实际上就是归并排序的思路。

该排序过程就是归并排序。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.count = 0

    def InversePairs(self, data):
        # write code here
        if len(data) < 2:
            return 0
        self.mergeSort(data)
        # 牛客网上要求输出要对1000000007取模
        #return self.count % 1000000007
        print(self.count % 1000000007)

    def mergeSort(self, data):
        if len(data) < 2:
            return data
        mid = len(data) // 2
        left = self.mergeSort(data[:mid])
        right = self.mergeSort(data[mid:])
        i, j = 0, 0
        res = []
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                res.append(left[i])
                i += 1
            else:
                res.append(right[j])
                j += 1
                self.count += (len(left) - i)

        return res + left[i:] + right[j:]



s=Solution()
s.InversePairs([7,6,5,4])