0

I'm trying to write code to find inversions in an array of numbers. I've seen the algorithm that uses Merge Sort to correctly do so, but have a question regarding the logic.

Why do we have to count the inversions in the left and right subarray and those between the two? I mean obviously that is correct, but why can't we just count all the inversions in the merge step? It turns out that at every level of doing merge the number of inversions can be counted directly, and after the subarray of twice the size is produced, the relative order of any two elements of it will never change in subsequent merge steps, which means we will never count any inversion that will not be an inversion in the end. So, what's wrong with the logic, cause it doesn't give the right answer.

I can explain more with examples and/or code if you want; intentionally didn't include the code so no one suspects this is homework.

Edit: So far I've found nothing wrong with the logic, but instead a bug in the code that leads to the wrong answer.

So, here's the method to find inversions in the array:

private void findInversions(int begin, int end, int count) {
    if (end - begin < 1)
        return;
    int middle = (begin + end) / 2;
    findInversions(begin, middle, count);
    System.out.println("But here count is " + count + " and I can't find why.");
    findInversions(middle + 1, end, count);
    count = mergeAndCount(begin, middle, end, count);
    System.out.println("count now is: " + count);
}

The mergeAndCount() method works the obvious way:

private int mergeAndCount(int begin, int middle, int end, int count) {

    int[] result = new int[end - begin + 1];
    int aptr = begin;
    int bptr = middle + 1;
    for (int i = 0; i < result.length; i++) {
        if (aptr <= middle && bptr <= end) {
            if (numbers[aptr] < numbers[bptr]) {
                result[i] = numbers[aptr];
                aptr++;
            }
            else {
                // (a[aptr], b[bptr]) is an inversion here
                count++;
                System.out.println("Found: (" + numbers[aptr] + "," + numbers[bptr] + "). If you print 'count' here it'll be one. See: " + count);
                result[i] = numbers[bptr];
                bptr++;
            }
        }
        else if (aptr > middle) {
            result[i] = numbers[bptr];
            bptr++;
        }
        else if (bptr > end) {
            result[i] = numbers[aptr];
            aptr++;
        }

    }

    for (int i = 0; i < result.length; i++) {
        numbers[begin + i] = result[i];
    }

    return count;

}

And I call the method with count set to zero: findInversions(0, numbers.length - 1, 0).

Obviously the problem is that count doesn't keep its value across different recursions. This is Java, so I don't need to pass it with the ampersand, and I even return its value in mergeAndCount(). So what's wrong here?

Goosal Tapal
  • 205
  • 1
  • 2
  • 5
  • This question belongs [here](http://cs.stackexchange.com/) rather than on SO. – Anmol Singh Jaggi May 06 '16 at 19:34
  • I always found it helpful to think of the algorithm as "undoing" each inversion (because a sorted array will have zero inversions). So as we sort the array with merge sort, we're keeping track of how many inversions we're *removing*, so by the time the array is completely sorted, we will have removed all of the inversions and therefore know how many inversions the original sequence had to start with. I'm not sure it this brief explanation helps at all, but I hope it's able to clear up some things conceptually. – Nick Zuber May 06 '16 at 19:38
  • @AnmolSinghJaggi First I thought it was a silly thought of mine, now I've found a bug in the code, so it's relevant here now. Please check the edit if you don't mind. – Goosal Tapal May 07 '16 at 05:34
  • @NickZuber Thanks for the insight, and it makes perfect sense. Now I've learned this is a code bug. Please check out the edit if you don't mind. – Goosal Tapal May 07 '16 at 05:35

0 Answers0