在nlgn时间内实现逆序对数的计算

        数组中逆序对的数量是同运行插入排序产生的移动的数量是相同的，但是选择排序的最差的时间复杂度是n的平方次，但是合并排序最差的是nlogn的时间复杂度。所以应该修改合并排序来计算逆序对数量。在L和R合并的过程中，如果没有移动的话，序列是L+R，所以计算移动的数量就是元素没有移动过R与L与R合并后的位置之间的差值就是移动的数量。

        以下代码是实现的算法：

1. #include <iostream>
3. const int MAXINT=0xFFFF-1;
5. void InversionMerge(int A[], int start, int mid, int end,int &c)
6. {
7.     int len1 = mid-start+1+1;//加一个位置用于保存哨兵
8.     int len2 = end-mid+1;//加一个位置用于保存哨兵
9.     int *L =new int[len1];
10.     int *R =new int[len2];
11.     for(int i=0;i<len1-1;i++)
12.         L[i]=A[start+i];
13.     L[len1-1]=MAXINT;
14.     for(int j=0;j<len2-1;j++)
15.         R[j]=A[mid+j+1];
16.     R[len2-1]=MAXINT;
17.     i=0;j=0;
18.     for(int k=start;k<=end;k++)
19.     {
20.         if(L[i]<=R[j])
21.         {
22.             A[k]=L[i];
23.             i++;
24.         }
25.         else
26.         {
27.             A[k]=R[j];
28.             c=c+((mid+1+j)-k);
29.             j++;
30.         }
31.     }
32. }
33. void InversionMergeSort(int A[], int start, int end,int &c)
34. {
35.     if(start<end)
36.     {
37.         int mid = (end +start)/2;
38.         InversionMergeSort(A,start,mid,c);
39.         InversionMergeSort(A,mid+1,end,c);
40.         InversionMerge(A,start,mid,end,c);
41.     }
42. }
45. int main(void)
46. {
47.     int *a;
48.     int c=0;//保存逆序对数量
49.     int n;
50.     std::cout<<"Please input the array's size: /n";
51.     std::cin>>n;
52.     a=new int[n];
53.     std::cout<<"Please input the array' value: "<<std::endl;
54.     for(int i=0;i<n;i++)
55.         std::cin>>a[i];
56.     InversionMergeSort(a,0,n-1,c);
57.     std::cout<<"The sorted number series: ";
58.     for(i=0;i<n;i++)
59.         std::cout<<" "<<a[i];
60.     std::cout<<std::endl;
61.     std::cout<<"the Inversion Number Is "<<c<<std::endl;
62.     return 0;
63. }

答案经检验是正确的，开心！