规并排序 以及 在其基础上的逆序对
写递归程序的时候，一定要注意其递归体的逻辑，另外假设子问题已经解决。
辅助函数只要解决好当前层自问体就好了，不要思考太多层次的东西，当然特殊的递归需求会有考虑多层次的东西。
merge(int l, int m, int r, int *a) {
l -> m
m+1->r 要合并
求逆序对个数的时候，可以在规并的过程中来数逆序对数。
L[]有序，R[]有序
那么L[I] <= R[J]时候，不需要累计逆序对数
否则L[I] > R[J]那么说明L[I] - > L[LEN_OF_LEFTPART] 都是与R[J]有逆序的关系。所以插入R[J]时候发现的逆序对数目是LEN_OF_LEFTPART-I+1
两边规并知道完成
return 当前层级的合并过程中的逆序对的个数。
}
merge_sort(int l, int r, int *a){
int cnt = 0, m = (l+r)>>1;
if( l < r ){
cnt += merge_sort(l, m, a); 左规并时候有几个逆序对
cnt += merge_sort(m+1,r, a);右规并的时候有几个逆序对
cnt += merge(l, m, r, a);当前曾规并的时候有几个逆序对，这个时候因为已经假设了右边和左边的是有序的。
}
return cnt;
}
源代码：
//============================================================================
// Name : integerPartition.cpp
// Author : jry
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
int merger(int l, int m, int r, int* a){
int llen = m-l+1, rlen = r-m;
int *L = new int [(llen)];
int *R = new int [(rlen)];
int i = l, j = 0, k = 0, ttcnt = 0;
for(; i <= m; i++) L[j++] = a[i];
for(j = 0; i <= r; i++ ) R[j++] = a[i];
i = j = 0;
k = l;
while(i < llen && j < rlen){
if(L[i] <= R[j]) a[k++] = L[i++];
else {
a[k++] = R[j++];
ttcnt += llen - i;
}
}
while( i < llen ) a[k++] = L[i++];
while( j < rlen ) a[k++] = R[j++];
delete[] (L);
delete[] (R);
return ttcnt;
}
int merger_sort(int l, int r, int *a){
int m = (l+r) / 2;
int tcnt = 0;
if( l < r ) {
tcnt += merger_sort(l, m, a);
tcnt += merger_sort(m+1, r, a);
tcnt += merger(l, m, r, a);
}
return tcnt;
}
int main() {
int a[] = {4, 1, 2, 3, 5, 1};
bool TESTMSort = false;
int n = sizeof(a)/sizeof(int);
if(TESTMSort) { for( int i = 0; i < n; i ++ ) cout << a[i] << " "; cout << endl;}
cout << "逆序对数: " << merger_sort(0, n-1, a) << endl;
cout << "DONE" << endl; // prints DONE
return 0;
}
