用divide&conquer思想解决求逆序数对的问题

对于一个给定的数组中要去求其中逆序数对的个数，可以通过简单的两层for循环去逐个便利每一个数对，这样的思想是很容易就可以想到

的，但是其算法的复杂度确是O（n^2）,为了降低算法的复杂度可以试着用divide&conquer思想去考虑这个问题。

对于一个数组{5，3，7，4，6，2，1，8}，如果我们以中间（或者左中）为界限将其分成两个数组，只要知道这两个数组中的逆序对数和两边

的数所组成的逆序对数就是它所有的逆序对数了。而数组划分的递归结束点在两个数组都只有一个元素的时候，因此两数组中的逆序对数可以

通过递归求得。要去求分裂的两数组中的逆序对数可以这样去做：先将两数组按升序排序，若前一个数组的第一个元素比后一个的大，则说

明前一组的后面所有都要比后一组的第一个元素大，这样将较小的第一个元素去掉后，继续比较两个数组的第一个元素可以把所有的逆序对找

到。

下面是该算法的JAVA实现：

import java.util.*;

public class CountInversedNumbers{

public static int count=0; //记录逆序对个数;

public void sort_count(int []L){

int n=L.length;

int a=(int)(n/2+0.5);

int b=(int)(n/2);

int A[]=new int[a];

int B[]=new int[b];

for (int i=0;i<a;i++)

A[i]=L[i];

for (int j=0;j<b;j++)

B[j]=L[j+a]; //把单个数组划分成两个数组;

if(a>1&&b>1) {

sort_count(A);

sort_count(B); //递归的划分数组;

}

Arrays.sort(A);

Arrays.sort(B); //将数组排序;

merge_count(A,B);

}

public void merge_count(int []M, int[]N){ //求被划分的两个数组中元素组成的逆序对;

int c=M.length;

int d=N.length;

while(c>0&&d>0)

{

if(M[0]>N[0]) {

this.count=this.count+c;

for(int i=0;i<d-1;i++)

N[i]=N[i+1];

d--;

}

else{

for(int j=0;j<c-1;j++)

M[j]=M[j+1];

c--;

}

}

}

public static void main(String[] args){

int K[]={6,2,3,5,7,1,4,8};

CountInversedNumbers a=new CountInversedNumbers();

a.sort_count(K);

System.out.println(a.count); //输出结果是11;

}

}