C 中的反转计数归并排序

Question

从 1 到 n 的整数排列是一个序列 a1, a2, ..., an，使得从 1 到 n 的每个 integer 在序列中恰好出现一次。

当较大的在较小的之前时，排列中的两个整数形成反转。

例如，在排列 4 2 7 1 5 6 3 中，总共有 10 次反转。 它们是以下对：4-2、4-1、4-3、2-1、7-1、7-5、7-6、7-3、5-3、6-3。

输入 n 和数组 [n] 2<=n<=100,000

首先我解决了冒泡排序的问题，但后来我遇到了时间复杂度问题。

其次我解决了它合并排序但我做得不好

这是我的绳子

#include <stdio.h>
#include <malloc.h>
int n;

void sizein(){
    scanf("%d",&n);
}

int count=0;
static void merge(int data[],int p,int q,int r){
    int i,j,l;
    int k=p;
    int sorted[n];
    for(i=p,j=q+1;i<=q&&j<=r;){
        sorted[k++]=(data[i]<=data[j]) ? data[i++]:data[j++];
        if(data[i>data[j]]){
            count+=q-i;
        }
    }
    if(i>q){
        for(l=j;l<=r;l++,k++){
            sorted[k]=data[l];
        }
    }
    else{
        for(l=i;l<=q;l++,k++){
            sorted[k]=data[l];
        }
    }
    for(l=p;l<=r;l++){
        data[l]=sorted[l];
    }
}

void merge_sort(int data[],int p,int r){
    if(p<r){
        int q=(p+r)/2;
        merge_sort(data,p,q);
        merge_sort(data,q+1,r);
        merge(data,p,q,r);
    }
}

int main(void){
    int i;
    int data[n];
    for(i=0;i<n;i++){
        scanf("%d",&data[i]);
    }
    merge_sort(data,0,n);
    printf("%d",count);
    return 0;
}

我应该在哪里修

Answer 1

我在您的代码中找不到一些实现位，它们根据索引将 arrays 划分为子数组（作为基于值的快速排序排序）请查看下面提供的代码

int q = p + (r - l) / 2;//recommended to be used in the function mergesort

int q=(p+r)/2;//your implementation

为您的 function 部分尝试此代码，因为我的代码在超过一百万个值的情况下运行良好，我无法清楚地看到在您的 function merge的实现中将值复制到的任何子数组我添加了注释以使您更容易理解，变量的术语略有不同。

有关此算法的生动解释，请参阅“ANANY LEVETIN-算法设计与分析简介”一书

看看并试试这个

void merge(int arr[], int l, int m, int r)
{
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
 
    /* create temp arrays */
    int L[n1], R[n2];
 
    /* Copy data to temp arrays L[] and R[] */
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
 
    /* Merge the temp arrays back into arr[l..r]*/
    i = 0; // Initial index of first subarray
    j = 0; // Initial index of second subarray
    k = l; // Initial index of merged subarray
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
 
    /* Copy the remaining elements of L[], if there
    are any */
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
 
    /* Copy the remaining elements of R[], if there
    are any */
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

/* l is for left index and r is right index of the
sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r)
{
    if (l < r) {
        // Same as (l+r)/2, but avoids overflow for
        // large l and h
        int m = l + (r - l) / 2;
 
        // Sort first and second halves
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
 
        merge(arr, l, m, r);
    }
}
 

/* Driver code */
int main()
{
    int arr[] = { 12, 11, 13, 5, 6, 7 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
 
    printf("Given array is \n");
    //printArray(arr, arr_size);
 
    mergeSort(arr, 0, arr_size - 1);
 
    printf("\nSorted array is \n");
    //printArray(arr, arr_size);
    return 0;
}

Answer 2

在阅读了一段时间的代码后，我仍然不能说我理解了计算反转的想法。 但是，我可以指出其中对我来说似乎不正确的三件事。

首先，我看不到你在哪里调用sizein() function 来初始化n变量。

第二个问题是这里的条件：

    if(data[i>data[j]]){
        count+=q-i;
    }

您将索引i与看起来很奇怪的数据项data[j]的值进行比较。 更糟糕的是，如果您要对一组几何图形或一组歌曲进行排序，由于要比较的数据类型不兼容，这可能是不可能的。 更糟糕的是，即使比较成功，例如int索引和data[]中的int值，如果比较满足，则比较结果为int值 1，否则为 0。 因此，此条件将解析为

    if(data[0]){
        count+=q-i;
    }

或者

    if(data[1]){
        count+=q-i;
    }

这显然是错误的。

正确的代码如下所示：

    if (data[i] > data[j]) {
        count += q - i;
    }

如果在运算符和它们的操作数之间留出适当的间距，错误会更加明显。

另一个错误潜伏在对merge_sort()的调用中。 首先，用这个循环填充data[]数组：

for (i = 0; i < n; i ++) {
    scanf("%d", &data[i]);
}

显然，您使用索引从0到n-1的数据填充n -items 数组。

然后调用合并排序例程：

merge_sort( data, 0, n);

这表明参数p是第一项或要排序的部分的索引，而q是最后一项。 但是，这与递归调用不同：

    merge_sort( data, p, q);
    merge_sort( data, q+1, r);

在第一次调用中设置q作为结束索引，在第二次调用中设置q+1作为开始索引表示结束索引是包含的，即它是要排序的段中最后一项的 position。 否则，这两个调用将使项data[q]未排序。 这也来自内部循环，当i <= q或 whle l <= r等时继续。

所以最初的电话不应该是

merge_sort( data, 0, n);

反而

merge_sort( data, 0, n-1);