归并排序和快速排序的衍生问题（一）

逆序对问题

首先我们介绍一下什么是逆序对？以下内容摘自百度百科：

设 A 为一个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。
如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数。

看完逆序对的概念后相信大家已经对逆序对有了一定的了解。现在我们来思考如何求出一个随机数据中逆序对的个数。不出所料的话，大家大概和本人一样想到了一个最简单但最笨的办法——遍历整个随机数据集，一个一个比较，如果是逆序对则计数器加1，反之则继续比较。

此办法在随机数据较少时不失为一个好办法，虽然其时间复杂度为O(n^2^)。但随机数据一旦较多，该办法就不适用了。既然之前我们学习了归并排序，那么能不能用此算法来解决该问题呢？答案肯定是可以的。

这里我们选用自底向上的归并排序算法，其算法思想为：假定待排序表含有n个记录，则可以看成是n个有序的子表，每个子表长度为1，然而两两归并，得到「n/2」个长度为2或1的有序表；再两两归并，······如此重复，直到合并成一个长度为n的有序表为止。

在合并arr[i…i+sz-1]和arr[i+sz…i+sz*2-1]这两个子表的过程中，当arr[i+sz] < arr[i]时，则存在sz个逆序对。因此，我们可以利用这一个规律求得随机数据集中的逆序对个数。

基本代码如下：

template<typename T>
long long __merge(T arr[], int l, int mid, int r) {

T aux[r - l + 1];
for (int i = 0; i <= r; i++)
aux[i - l] = arr[i];

int i = l, j = mid + 1;
long long count = 0;
for (int k = l; k <= r; k++) {

if (i > mid) {
arr[k] = aux[j - l];
j++;
} else if (j > r) {
arr[k] = aux[i - l];
i++;
} else if (aux[i - l] < aux[j - l]) {
arr[k] = aux[i - l];
i++;
} else {
arr[k] = aux[j - l];
count += (long long) (mid - i + 1);
j++;
}
}
return count;
}

template<typename T>
long long inversionCount(T arr[], int n) {

long long count;

for (int step = 1; step <= n; step += step) {

for (int i = 0; i + step < n; i += step + step) {

count = __merge(arr, i, i + step - 1, min(i + step + step - 1, n - 1));
}
}
return count;
}

为了测试该算法在完全有序和完全无序的随机数据集的情况下是否正确，我们在TestHelper.h文件中添加如下代码：

// 生成一个完全有序的数组
int *generateOrderedArray(int n) {

return generateNearlyOrderedArray(n, 0);
}

// 生成一个完全逆序的数组
int *generateInversedArray(int n) {

int *arr = generateOrderedArray(n);
for (int i = n / 2 - 1; i >= 0; i--)
swap(arr[i], arr[n - i - 1]);
return arr;
}

然后我们在main()中调用，看看其运行结果吧：

Test Inversion Count for Random Array, n = 100000 :
2511332485

Test Inversion Count for Ordered Array, n = 100000 :
0

Test Inversion Count for Inversed Array, n = 100000 :
4999950000

除此之外，我们还可以使用自顶向下的归并排序算法来求取随机数据集中的逆序对个数，其算法思想为：假定待排序表含有n个记录，递归地将前半部分记录和后半部分记录各自归并，得到排序后的两部分记录，然后再使用合并算法将这两部分合并在一起。

其基本代码如下：

// merge函数求出在arr[l...mid]和arr[mid+1...r]有序的基础上, arr[l...r]的逆序数对个数
template<typename T>
long long __merge(T arr[], int l, int mid, int r) {

int *aux = new int[r - l + 1];
for (int i = l; i <= r; i++)
aux[i - l] = arr[i];

// 初始化逆序数对个数 res = 0
long long res = 0;
// 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
int j = l, k = mid + 1;
for (int i = l; i <= r; i++) {
if (j > mid) { // 如果左半部分元素已经全部处理完毕
arr[i] = aux[k - l];
k++;
} else if (k > r) { // 如果右半部分元素已经全部处理完毕
arr[i] = aux[j - l];
j++;
} else if (aux[j - l] <= aux[k - l]) { // 左半部分所指元素 <= 右半部分所指元素
arr[i] = aux[j - l];
j++;
} else { // 右半部分所指元素 < 左半部分所指元素
arr[i] = aux[k - l];
k++;
// 此时, 因为右半部分k所指的元素小
// 这个元素和左半部分的所有未处理的元素都构成了逆序数对
// 左半部分此时未处理的元素个数为 mid - j + 1
res += (long long) (mid - j + 1);
}
}

delete[] aux;

return res;
}

// 求arr[l..r]范围的逆序数对个数
// 思考: 归并排序的优化可否用于求逆序数对的算法? :)
template<typename T>
long long __inversionCount(T arr[], int l, int r) {

if (l >= r)
return 0;

int mid = l + (r - l) / 2;

// 求出 arr[l...mid] 范围的逆序数
long long res1 = __inversionCount(arr, l, mid);
// 求出 arr[mid+1...r] 范围的逆序数
long long res2 = __inversionCount(arr, mid + 1, r);

return res1 + res2 + __merge(arr, l, mid, r);
}

// 递归求arr的逆序数对个数
template<typename T>
long long inversionCount(T arr[], int n) {

return __inversionCount(arr, 0, n - 1);
}

其运行结果为：

Test Inversion Count for Random Array, n = 1000000 :
250154505378

Test Inversion Count for Ordered Array, n = 1000000 :
0

Test Inversion Count for Inversed Array, n = 1000000 :
499999500000