一、基础算法-02归并排序

持续为你更新！

1.归并排序

归并排序（Merge Sort）是一种经典的分治算法，它的基本原理可以简述如下：
分解（Divide）：将原始数组分解成若干个子数组，直到每个子数组只包含一个元素为止。这样得到的子数组是有序的。
解决（Conquer）：逐个将相邻的子数组进行合并，合并过程中保持元素的有序性。合并的过程中，通过比较两个子数组的第一个元素，将较小（或较大）的元素放入一个新的临时数组中。
合并（Combine）：重复进行合并操作，直到所有子数组合并成一个完整的数组，此时整个数组已经有序。
这个过程可以用递归来实现，每次递归都将数组划分为两半，直到每个子数组只有一个元素为止，然后通过合并操作将两个有序的子数组合并成一个更大的有序数组。
归并排序的时间复杂度为O(nlogn)，其中n是待排序数组的大小。虽然归并排序需要额外的空间来存储临时数组，但是其稳定性和高效性使得它在实践中被广泛应用。
归并排序的时间复杂度为什么为O(nlogn)?
时间复杂度中的log（n）底数是多少？
归并排序的时间复杂度为什么为nlogn

1.1模板

归并模板

void merge_sort(int q[], int l, int r)
{
    //递归的终止情况
    if(l >= r) return;
    //第一步：分成子问题
    int mid = l + r >> 1;
    //第二步：递归处理子问题
    merge_sort(q, l, mid ), merge_sort(q, mid + 1, r);
    //第三步：合并子问题
    int k = 0, i = l, j = mid + 1, tmp[r - l + 1];
    while(i <= mid && j <= r)
        if(q[i] <= q[j]) tmp[k++] = q[i++];
        else tmp[k++] = q[j++];
    while(i <= mid) tmp[k++] = q[i++];
    while(j <= r) tmp[k++] = q[j++];
    for(k = 0, i = l; i <= r; k++, i++) q[i] = tmp[k];
}

1.2实战

C++解法：

#include <iostream>
using namespace std;
const int N=1000010;
int q[N];
void merage_sort(int q[],int l,int r)
{
    if(l>=r) return;
    int mid=l+r>>1;
    merage_sort(q,l,mid),merage_sort(q,mid+1,r);
    int k=0,i=l,j=mid+1,tep[r-l+1];
    while(i<=mid &&j<=r)
    {
        if(q[i]<q[j]) tep[k++]=q[i++];
        else tep[k++]=q[j++];
    }
    while(i<=mid) tep[k++]=q[i++];
    while(j<=r) tep[k++]=q[j++];
    for(int k=0,i=l;i<=r;k++,i++) q[i]=tep[k];
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    merage_sort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
}

Python解法：

def merage_sort(l,r):
    if l>=r: return 0
    mid=l+r>>1
    merage_sort(l,mid),merage_sort(mid+1,r)
    i,j,temp,=l,mid+1,[]
    while i<=mid and j<=r:
        if q[i]<q[j]:
            temp.append(q[i])
            i+=1
        else:
            temp.append(q[j])
            j+=1
    #扫尾
    temp.extend(q[i:mid+1])
    temp.extend(q[j:r+1])
    #物归原主
    q[l:r+1]=temp
n=int(input())
q=list(map(int,input().split()))
merage_sort(0,n-1)
print(" ".join(map(str,q)))

3逆序对数量

什么叫逆序对，就是一个大的数排在前面和它后面的，比它小的数组成一个逆序对。
首先我们给出逆序对的定义：
对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对。
重要的地方在于，一个元素可以不只是在一个逆序对中存在。如果 k > j > i 且 a[i] > a[j] > a[k]，那么这里
有两个含 a[i] 的逆序对，分别是 (a[i], a[j]) 和 (a[i], a[k]), a[i]是可以使用多次的。
那么第二步是分析问题，这里我们可以使用分治法解决问题。
我们将序列从中间分开，将逆序对分成三类：
两个元素都在左边；
两个元素都在右边；
两个元素一个在左一个在右；
因此这就是我们算法的大致框架：
计算逆序对的数量（序列）：

1. 递归算左边的；
2. 递归算右边的；
3. 算一个左一个右的；
4. 把他们加到到一起。

这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的，因此我们可以数完就给它排序。这么做的好处在于，如果序列是有序的，会让第三步计数很容易。
如果无序暴力数的话这一步是O(n^2)的。
比如序列是这样的

4 5 6 | 1 2 3

当你发现 4 比 3 大的时候，也就是说右边最大的元素都小于左边最小的元素，那么左边剩下的5和6都必然比右边的所有元素大，因此就可以不用数5和6的情形了，直接分别加上右半边的元素个数就可以了，这一步就降低到了O(n), 我们知道递归式 T(n) = 2T(n/2)+O(n) = O(nlogn)的，所以排序的成本是可以接受的，并且这一问题下,很自然的用归并。

4.逆序对数量实战

C++解法：

#include <iostream>
using namespace std;
typedef long long LL;
const int N=1e5+10;
int q[N],temp[N];
LL merage_sort(int q[],int l,int r)
{
    if(l>=r) return 0;
    int mid=l+r>>1;
    LL res=merage_sort(q,l,mid)+merage_sort(q,mid+1,r);
    int k=0,i=l,j=mid+1;
    while(i<=mid && j<=r)
    {
        if(q[i]<=q[j]) temp[k++]=q[i++];
        else
        {
            res+=mid-i+1;
            temp[k++]=q[j++];
        }
    }
    while(i<=mid) temp[k++]=q[i++];
    while(j<=r) temp[k++]=q[j++];
    for(i=l,k=0;i<=r;i++,k++) q[i]=temp[k];
    return res;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    cout<<merage_sort(q,0,n-1)<<endl;
    return 0;
}

Python解法：

def merage_sort(l,r):
    if l>=r:
        return 0
    mid=l+r>>1
    res=merage_sort(l,mid)+merage_sort(mid+1,r)
    i,j,temp=l,mid+1,[]
    while i<=mid and j<=r:
        if q[i]<=q[j]:
            temp.append(q[i])
            i+=1
        else:
            temp.append(q[j])
            j+=1
            res+=mid-i+1
    if i<=mid:
        temp.extend(q[i:mid+1])
    if j<=r:
        temp.extend(q[j:r+1])
    q[l:r+1]=temp
    return res
            
n=int(input())
q=list(map(int,input().split()))
print(merage_sort(0,n-1))