倒置问题：A[0…n-1]是⼀个n个不同实数构成的数组，如果 i＜j, 但是 A[i] ＞A[j],则这对元素（A[i]，A[j])被称为⼀个倒置。设计⼀个O(nlogn)算法来计算数组中的倒置数

#include <stdio.h>
#include <stdlib.h>
long long mergeSort(int arr[], int temp[], int left, int right);
long long merge(int arr[], int temp[], int left, int mid, int right);
long long countInversions(int arr[], int n) {
    int *temp = (int *)malloc(sizeof(int) * n);
    return mergeSort(arr, temp, 0, n - 1);
}
long long mergeSort(int arr[], int temp[], int left, int right) {
    long long inversions = 0;	 
    if (left < right) {
    	int mid = (left + right) / 2;
        inversions += mergeSort(arr, temp, left, mid);
        inversions += mergeSort(arr, temp, mid + 1, right);
        inversions += merge(arr, temp, left, mid + 1, right);
    }
    return inversions;
}
long long merge(int arr[], int temp[], int left, int mid, int right) {
    int i = left;int j = mid;int k = left;long long inversions = 0;
    while (i <= mid - 1 && j <= right) {
        if (arr[i] <= arr[j]) {temp[k++] = arr[i++];}
        else {temp[k++] = arr[j++];inversions += mid - i;}
    }
    while (i <= mid - 1) {temp[k++] = arr[i++];}
    while (j <= right) {temp[k++] = arr[j++];}
    for (i = left; i <= right; i++) {arr[i] = temp[i];}
    return inversions;
	}
int main() {
    int n;
    printf("请输入n的个数：");
    scanf("%d", &n);
    int *arr = (int *)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) 
	{printf("请输入第%d个数:",i+1);scanf("%d", &arr[i]);}
    long long result = countInversions(arr, n);
    printf("%lld\n", result);
    free(arr);
    return 0;
}

归并排序的核心思想就是分治法，把一个大问题分成若干个小问题，然后递归地解决每个小问题，最后把所有小问题的解合并起来，就可以得到整个问题的解。
在这个问题中，我们可以将数组分成两部分，然后递归地计算出每一部分的逆序对数量，最后再计算出横跨两个部分的逆序对数量。具体的实现过程如下：

1. 函数 `countInversions()` 接受一个数组 `arr` 和数组的长度 `n`，返回值为逆序对的数量。在函数内部，我们动态分配一个临时数组 `temp`，用于在归并过程中临时存储排序后的结果。

```c
long long countInversions(int arr[], int n) {
    int *temp = (int *)malloc(sizeof(int) * n);
    return mergeSort(arr, temp, 0, n - 1);
}
```

2. 函数 `mergeSort()` 接受一个数组 `arr`、临时数组 `temp`、左边界 `left` 和右边界 `right`，返回值为左右两部分的逆序对数量。
在函数内部，我们首先判断是否满足 `left < right`，如果不满足，则返回 0，因为此时数组只有一个元素，无法统计逆序对数量。
如果满足，则计算出中间位置 `mid`，然后递归地计算左半部分和右半部分的逆序对数量，并计算合并过程中的逆序对数量，最后将三部分逆序对数量相加并返回。

```c
long long mergeSort(int arr[], int temp[], int left, int right) {
    long long inversions = 0;
    if (left < right) {
        int mid = (left + right) / 2;
        inversions += mergeSort(arr, temp, left, mid);
        inversions += mergeSort(arr, temp, mid + 1, right);
        inversions += merge(arr, temp, left, mid + 1, right);
    }
    return inversions;
}
```

3. 函数 `merge()` 接受一个数组 `arr`、临时数组 `temp`、左边界 `left`、中间位置 `mid` 和右边界 `right`，返回值为横跨左右两部分的逆序对数量。
在函数内部，我们维护三个指针 `i`、`j` 和 `k`，分别指向左半部分、右半部分和临时数组的当前位置。
我们比较 `arr[i]` 和 `arr[j]` 的大小，如果 `arr[i] <= arr[j]`，则将 `arr[i]` 存入临时数组，并将 `i` 和 `k` 分别加 1；否则，将 `arr[j]` 存入临时数组，并累加逆序对数量 `mid - i`，因为此时左半部分中 `i` 及其之后的数都大于 `arr[j]`，需要将其逆序对数量累加到结果中。最后，将剩余的左半部分或右半部分存入临时数组中，最终将临时数组中的结果复制回原数组。

```c
long long merge(int arr[], int temp[], int left, int mid, int right) {
    int i = left;
    int j = mid;
    int k = left;
    long long inversions = 0;
    while (i <= mid - 1 && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        }
        else {
            temp[k++] = arr[j++];
            inversions += mid - i;
        }
    }
    while (i <= mid - 1) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    for (i = left; i <= right; i++) {
        arr[i] = temp[i];
    }
    return