计算给定数组中的反转次数

Question

I tried to solve this problem using merge sort but there is something wrong with my solution. I checked number of inversions while merging the array. Can someone help me find the issue?

void merge(int arr[], int l, int m, int r)
{
    int n1=m-l+1;
    int n2=r-m;
    int left[(n1+1)];
    int right[(n2+1)];
    for(int i=0;i<n1;i++){
        left[i]=arr[l+i];
    }
    for(int j=0;j<n2;j++){
        right[j]=arr[m+j+1];
    }
    left[n1]=INT_MAX;
    right[n2]=INT_MAX;
    int i=0, j=0;
    //int inv=0;
    for(int k=l;k<=r;k++){
        if(left[i]<=right[j]){
            arr[k]=left[i];
            i++;
        }
        else{
            arr[k]=right[j];
            j++;
            inv+=(m-i);
        }
    }
    //return inv;
}

void mergeSort(int arr[], int l, int r) {
    int inv=0;
    if (l < r) {
        int m = l+(r-l)/2;
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        merge(arr, l, m, r);
    }
    // return inv;
} 

Answer 1

You are doing everything correctly, except that you have to add n1 - i to inv instad of m - i .

The reasoning behind that is the following. When you take a number from the "right" part, it is lower than any number in the "left" part that hasn't been taken yet, and thus such pairs form inversions. The number of untaken items from "left" part is n1 - 1 [last number from actual array. INT_MAX is stored at index n1 ] - i [current untaken item] + 1 [because the indices are inclusive], which simplifies to n1 - i .

Please also note that the number of inversions can be as high as O(n ^ 2) , where n is the size of the array, so you might want to store the number of inversions in a long long variable.

The final version of the code:

int merge(int arr[], int l, int m, int r)
{
    int n1=m-l+1;
    int n2=r-m;
    int left[(n1+1)];
    int right[(n2+1)];
    for(int i=0;i<n1;i++){
        left[i]=arr[l+i];
    }
    for(int j=0;j<n2;j++){
        right[j]=arr[m+j+1];
    }
    left[n1]=INT_MAX;
    right[n2]=INT_MAX;
    int i=0, j=0;
    int inv=0;
    for(int k=l;k<=r;k++){
        if(left[i]<=right[j]){
            arr[k]=left[i];
            i++;
        }
        else{
            arr[k]=right[j];
            j++;
            inv += n1 - i;
        }
    }
    return inv;
}

int mergeSort(int arr[], int l, int r) {
    int inv=0;
    if (l < r) {
        int m = l+(r-l)/2;
        inv += mergeSort(arr, l, m);
        inv += mergeSort(arr, m+1, r);
        inv += merge(arr, l, m, r);
    }
    return inv;
}