利用merge sort寻找逆序对

算法导论第二章 练习题，使用合并排序算法寻找逆序对

基本思想：

•  在merge过程中，交换位置与一组逆序对是一一对应的。
• 在左右两个子数组内部是排好序的，所以逆序对的出现仅仅存在于“左数组中的数组大有右数组中的数字”的情况。 所以在每次的merge过程中就可以进行逆序对的计数。

java代码实现：

    public class InversionCount {
        public static void main(String[] args){
            int[] arr = new int[]{2,30,19,6,7,3,5};
            System.out.println("before sort：");
            Sort.printarr(arr);
            int num = countinversion(arr,0,arr.length-1);
            System.out.println("the number of arr's inversions :"+num);
        }
    
        private static int countinversion(int[] arr,int start,int end) {
            int count = 0;
            if(start<end){
                int divide = (end+start)/2;
                count+=countinversion(arr,start,divide);
                count+=countinversion(arr,divide+1,end);
                count+=countmerge(arr,start,end,divide);
            }
            return count;
        }
    
        private static int countmerge(int[] arr, int start, int end, int divide) {
            int count = 0;
            //三个指针的初始化
            int i = 0;
            int j = 0;
            int k = start;
            boolean flag = false;
            //创建左右子数组，并赋值
            int lsize = divide-start+1;
            int rsize = end-divide;
            int[] arrL = new int[divide-start+1];
            int[] arrR = new int[end-divide];
            for(int n =0;n<lsize;n++){
                arrL[n] = arr[n+start];
            }
            for(int n =0;n<rsize;n++){
                arrR[n] = arr[n+divide+1];
            }
            //三个指针移动，进行合并
            while(k<end+1){
                if(arrL[i]>arrR[j]&&flag==false){
                    count+=lsize-i;
                    flag = true;
                }
                if(arrL[i]<arrR[j]){
                    arr[k]=arrL[i];
                    k++;
                    i++;
                    if(i>=lsize)
                        break;
                }else{
                    arr[k]=arrR[j];
                    k++;
                    j++;
                    flag = false;
                    if(j>=rsize)
                        break;
                }
            }
            //把剩余的都填进arr
            while(i<lsize){
                arr[k]=arrL[i];
                k++;
                i++;
                //count++;
            }
            while(j<rsize){
                arr[k]=arrR[j];
                k++;
                j++;
            }
            System.out.print("    本次递归的结果：");
            Sort.printarr(arr);
            System.out.println("    本次的计数"+count);
            return count;
        }
    }

运行结果：

before sort：
	2,30,19,6,7,3,5
	    本次递归的结果：2,30,19,6,7,3,5
	    本次的计数0
	    本次递归的结果：2,30,6,19,7,3,5
	    本次的计数1
	    本次递归的结果：2,6,19,30,7,3,5
	    本次的计数2
	    本次递归的结果：2,6,19,30,3,7,5
	    本次的计数1
	    本次递归的结果：2,6,19,30,3,5,7
	    本次的计数1
	    本次递归的结果：2,3,5,6,7,19,30
	    本次的计数8
	the number of arr's inversions :13