算法导论部分习题备注

2.4 Inversions

Let A[1...n]be an array of n distinct numbers. If i < j and A[i] > A[j], then the
pair(i, j)is called an inversion of A.
Give an algorithm that determines the number of inversions in any permutation
on n elements in O(nlgn) worst-case time. (Hint: Modify merge sort.)

Thinking: We may think both A[i…j] and A[j+1…k] are sorted subarray of A (0 <= i < j < k <= n). if A[x](i<=x<=j) is bigger than A[j+1], then all numbers behind A[x] are bigger than A[j+1], so there are j-x+1 inversions bigger than A[j+1].

class Solution {
public:
    int getInversionNumbers(vector<int>& data, int begin, int end) {
        if (begin < end - 1) {
            int middle = (begin + end - 1) / 2;
            int left = solute(data, begin, middle + 1);
            int right = solute(data, middle + 1, end);
            return findAndSort(data, begin, middle + 1, end) + left + right;
        }
        return 0;
    }

private:
    int findAndSort(vector<int>& data, int start, int middle, int end) {
        vector<int> left(data.begin() + start, data.begin() + middle);
        vector<int> right(data.begin() + middle, data.begin() + end);

        int i = 0, j = 0, k = start;
        int count = 0;
        while (i < left.size() && j < right.size()) {
            if (left[i] > right[j]) {
                // If current item in left bigger than the the current item of right,
                // then all items after current left item is bigger than the left.
                count += left.size() - i;
                data[k++] = right[j++];
            } else {
                data[k++] = left[i++];
            }
        }
        while (i < left.size()) data[k++] = left[i++];
        while (j < right.size()) data[k++] = right[j++];

        return count;
    }
};