归并排序 和 逆序对 联动

归并排序（Merge Sort）是一种经典的分而治之（Divide and Conquer）排序算法，常被用于对数组或列表进行排序。它的基本思想是将待排序的序列分成两部分，分别对这两部分进行排序，然后将排序后的两部分合并为一个有序序列。归并排序的时间复杂度为O(n log n)，它具有稳定性，适用于各种数据类型。

下面是归并排序的基本步骤和C++示例代码：

1. 分割（Divide）：将待排序的序列分成两个大致相等的子序列，递归地对子序列进行排序。这一步一直持续到子序列中只有一个元素或没有元素。

2. 合并（Merge）：将两个有序的子序列合并为一个有序的序列。合并过程中，从两个子序列中选取较小的元素放入新的有序序列，直到两个子序列中的所有元素都被合并。

以下是C++的归并排序示例代码：

#include 
#include 

// 合并两个有序子序列
void merge(std::vector& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    std::vector L(n1);
    std::vector R(n2);

    for (int i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[mid + 1 + j];
    }

    int i = 0, j = 0, k = left;

    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// 归并排序
void mergeSort(std::vector& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
    std::vector arr = {38, 27, 43, 3, 9, 82, 10};

    std::cout << "原始数组：";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    mergeSort(arr, 0, arr.size() - 1);

    std::cout << "排序后的数组：";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码演示了如何使用归并排序对一个整数数组进行排序。首先，mergeSort函数递归地分割和排序数组，然后通过merge函数将两个有序的子数组合并为一个有序数组。最后，在main函数中，你可以看到如何使用这些函数来排序一个示例数组。

归并排序是一个高效的排序算法，适用于大规模数据集的排序，因为它的时间复杂度稳定在O(n log n)。

下面我们修改代码来计算逆序对的数目

逆序对是指在数组中的一对元素 (arr[i], arr[j])，其中 i < j 且 arr[i] > arr[j]。以下是一个C++示例代码，演示如何计算数组的逆序对数目：

#include 
#include 

// 合并并统计逆序对
long long mergeAndCount(std::vector& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    std::vector L(n1);
    std::vector R(n2);

    for (int i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[mid + 1 + j];
    }

    long long count = 0;
    int i = 0, j = 0, k = left;

    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
            // 当发现 L[i] > R[j] 时，L[i] 和 R[j] 之间存在逆序对
            count += (n1 - i);
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }

    return count;
}

// 归并排序并返回逆序对数目
long long mergeSortAndCount(std::vector& arr, int left, int right) {
    long long count = 0;
    if (left < right) {
        int mid = left + (right - left) / 2;
        count += mergeSortAndCount(arr, left, mid);
        count += mergeSortAndCount(arr, mid + 1, right);
        count += mergeAndCount(arr, left, mid, right);
    }
    return count;
}

int main() {
    std::vector arr = { 5, 2, 6, 1 };

    std::cout << "原始数组：";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    long long inversionCount = mergeSortAndCount(arr, 0, arr.size() - 1);

    std::cout << "逆序对数目：" << inversionCount << std::endl;

    std::cout << " 排完序的数组如下  " << std::endl;
    for (int x : arr)
        std::cout << x << " ";
    return 0;
}