超快速排序

介绍

给定一个长度为n的序列a，如果只允许进行比较和交换 相邻两个数的操作，求至少需要多少次交换才能把a从小到大排序

思想

只通过上述方法实际上就是使用冒泡排序，每一交换实际上就是两个相邻的数构成了逆序对，因此总共需要交换的次数就是序列a中逆序对的个数

完整代码

#include <iostream>

using namespace std;

void input(int arr[], int size){
    for(int i = 0; i < size; i++)
        cin >> arr[i];
}

long long merge(int arr[], int L, int mid, int R){
    long long ans = 0;
    int *helpArr = new int[R - L + 1];
    int cur = 0;
    int p1 = L;
    int p2 = mid + 1;
    while(p1 <= mid && p2 <=R){
        if(arr[p1] > arr[p2])
            ans += mid-p1+1;
        helpArr[cur++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
    }
    while(p1 <= mid){
        helpArr[cur++] = arr[p1++];
    }
    while(p2 <= R){
        helpArr[cur++] = arr[p2++];
    }
    for(int i = 0; i < R-L+1; i++)
        arr[L+i] = helpArr[i];
    return ans;
}


long long sortProcess(int arr[], int L, int R){
    if(L == R)
        return 0;
    int mid = L + ((R - L) >> 1);
    return sortProcess(arr, L, mid)+
    sortProcess(arr, mid+1, R)+
    merge(arr, L, mid, R);
}

long long mergeSort(int arr[], int size){
    return sortProcess(arr, 0, size-1);
}

int main()
{
    int n;
    while(cin >> n){
        if(n == 0) return 0;
        int *arr = new int[n];
        input(arr, n);
        cout << mergeSort(arr, n) << endl;
    }
    return 0;
}