Question

我知道Stack中有很多这样的实现，但是我遇到了一些我无法解决的问题。

首先，我使用javascript在khanacademy实现了合并排序，然后我将代码重写为C ++，并尝试计算数组中的反转次数。

我尽我所能，并花了一个小时试图了解我做错了什么。我在堆栈中搜索了另一个实现，并试图纠正我的代码。不幸的是，我不知道我做错了什么。我认为我算上每一次倒错。提前感谢您帮助理解错误。

我的代码：

int lowhalflength(int p, int q)
{
    return q - p + 1;
}

int highhalflength(int q, int r)
{
    return r - q;
}


int merge(int array[], int p, int q, int r, int lowhalf[], int highhalf[])
{
    int k = p;
    int i;
    int j;
    int count = 0;
    for (int i = 0; k <= q; i++ , k++)
    {
        lowhalf[i] = array[k];
    }
    for (int i = 0; k <= r; i++ , k++)
    {
        highhalf[i] = array[k];
    }

    k = p;
    i = 0;
    j = 0;

    while (i <= (q - p) && j <= r - (q + 1))
    {
        if (lowhalf[i] <= highhalf[j])
        {
            array[k] = lowhalf[i];
            i++;
        }
        else
        {
            array[k] = highhalf[j];
            j++;
            count += q - 1;
        }

        k++;
    }

    while (i < lowhalflength(p, q))
    {
        array[k] = lowhalf[i];
        k++;
        i++;
    }

    while (j < highhalflength(q, r))
    {
        array[k] = highhalf[j];
        k++;
        j++;
    }


    return count;
}

mergeSort函数：

int mergeSort(int array[], int p, int r)
{
    int q = ((p + r) / 2);
    int* lowhalf = new int[lowhalflength(p, q)];
    int* highhalf = new int[highhalflength(q, r)];

    int count = 0;
    if (p < r)
    {
        q = ((p + r) / 2);
        count = mergeSort(array, p, q);
        count += mergeSort(array, q + 1, r);
        count += merge(array, p, q, r, lowhalf, highhalf);
    }
    delete[] lowhalf;
    delete[] highhalf;
    return count;
}

对于数组[10,9,8,7,6,5,4,3,2,1]，输出为46，而应为45.

修改答案是将以下行q-1更改为q+j-k.我自己找到了它，但我不知道应该如何解释它。任何提示或证明为什么它是正确的将是非常可取的。

Answer 1

您可以使用我的代码来计算反转对，并且您的合并函数应该以更有效的方式看起来像这样：

int merge(int *array, int lower, int mid, int upper) {

    // Initialisation of the sizes of two subarrays and subarrays also.
    int left_array_size = mid - lower + 1;
    int right_array_size = upper - mid;
    int left_array[left_array_size], right_array[right_array_size];

    int j = 0;
    for (int i = lower; i <= mid; i++) {
        left_array[j++] = array[i];
    }
    j = 0;
    for (int i = mid + 1; i <= upper; i++) {
        right_array[j++] = array[i];
    }

    // Performing merging in a non-increasing manner and count inversion pairs..
    int i = 0, k;
    j = 0;
    int resultIntermediate = 0;
    for (k = lower; k <= upper; ) {
        if (left_array[i] <= right_array[j]) {
            array[k++] = left_array[i++];
            if (i >= left_array_size)   break;
        }
        else {
            array[k++] = right_array[j++];

            // If a element in left_array_size is greater than an element from
            // right_array_size then rest of all other elements will also be
            // greater than that element of right_array_size because both
            // subarrays are sorted in non-decreasing order.
            resultIntermediate += left_array_size - i;

            if (j >= right_array_size)  break;
        }
    } //end of for loop.


    // Performing merging if i or j doesn't reach to its
    // maximum value i.e. size of the subarrays.
    while (i < left_array_size) {
        array[k++] = left_array[i++];
    }
    while (j < right_array_size) {
        array[k++] = right_array[j++];
    }

    // Returning the result...
    return resultIntermediate;

} //end of the merge function.

计数反转对的功能

int countInversionPair(int *array, int lower, int upper) {
    int count_inv_pair = 0;
    // Do recusion untill the problem / array can be subdevided.
    if (lower < upper) {

        // Partition the Array into two subproblems.
        int mid = (lower + upper) / 2;

        // Call the countInversionPair() function for these two
        // subarrays / subproblems recursively to count number of
        // inversion for these subproblems / subarrays.
        count_inv_pair = countInversionPair(array, lower, mid);
        count_inv_pair += countInversionPair(array, mid + 1, upper);

        // Merge these two subarrays into a sigle array
        count_inv_pair += merge(array, lower, mid, upper);
    }
    return count_inv_pair;
}

现在你可以通过从main调用函数来获得反转对的数量：

int count_inv_pair = countInversionPair(array, 0, size - 1);

现在你会得到答案..

Answer 2

非常感谢你们所有人，尤其是@Shiv和@WhozCraig，你们给了我并想出如何解决它。答案是将def find_pairs(x, sum): s = set(L) for i in L: diff = 10-i s.remove(i) if diff in s: print i, diff L = [2, 45, 7, 3, 5, 1, 8, 9] sum = 10 find_pairs(L, sum)更改为q-1

使用合并排序计算反转

2 个答案: