两道关于逆序对的题目

import java.util.Arrays;

public class 合并有序数组 {

    public static void main(String[] args) {
    
        int A[] = new int[12];
        for (int i = 0; i < 7; i++) {
            A[i] = 2*i+1;
        }
        System.out.println("A数组："+Arrays.toString(A));
        
        int B[] = new int[5];
        for (int i = 0; i < B.length; i++) {
            B[i] = 3*i+1;
        }
        System.out.println("B数组："+Arrays.toString(B));
        
        int []res = f(A,7,B,5);
        System.out.println("合并后的数组："+Arrays.toString(res));
   
        
    }

    private static int[] f(int []A,int p, int B[],int r) {
        int current = p+r-1;
        p--;
        r--;
        while(p!=-1&&r!=-1){
            if (A[p]>=B[r]) {
                A[current] = A[p];
                current--;
                p--;
            }else {
                A[current] = B[r];
                current--;
                r--;
            }
        }
        return A;
    }

    
}

import java.util.Arrays;

public class 逆序对 {
    
    static int niXuNum = 0;

    public static void main(String[] args) {
        int arr[] = new int[10];
        for(int i=0;i<10;i++){
            arr[i] = (int) ((Math.random()+1)*10);
        }
        
        
        System.out.println("数组元素："+Arrays.toString(arr));
        mergeSort(arr, 0, arr.length-1);
//        System.out.println("排序后："+Arrays.toString(arr));
        
        System.out.println("逆序对个数："+niXuNum);

    }
    
    /**
     * 思路：将数组分为左右两个数组，递归调用归并进行排序
     *         分别排序完成后，使用辅助的合并函数将两个有序的子数组合并成一个整体有序的数组
     * 时间复杂度：均：O(nlgn),好：O(nlgn),坏：O(nlgn)
     * 空间复杂度：需要开辟辅助空间，该辅助空间可以重用，大小为N
     * 非原址排序
     * 稳定性：所有排序都是归并，在左的永远在左，在右的永远在右，稳定
     */
    
    static int[]helper;
    
    private static void mergeSort(int[] arr, int p, int r) {
        
        if (p<r) {
            int mid = p + ((r-p)>>1);
            mergeSort(arr, p, mid);  // 对左侧排序
            mergeSort(arr, mid+1, r);  // 对右侧排序
            merge(arr,p,mid,r);    // 合并
        }
        
    }

    private static void merge(int[] arr, int p, int mid, int r) {
        
        // 下面这行代码只能在这里使用，不能在主方法使用。
        helper = Arrays.copyOf(arr, arr.length);  //开辟的一个辅助空间  并拷贝数据
        
        int left = p;  // 左侧队伍的头部指针，指向待比较的元素
        int right = mid + 1;   // 右侧队伍的头部指针，指向待比较的元素
        int current = p;       // 原数组的指针，指向待填入数据的位置
        
        while(left<=mid&&right<=r){
            if (helper[left]<=helper[right]) {
                arr[current] = helper[left];
                current++;
                left++;
            }else {   // 右边小
                arr[current] = helper[right];
                current++;
                right++;
                niXuNum += mid-left+1;
            }
        }
        
        // 如果辅助数组右侧的数据没有全部填入原数组  那么不用管 因为原数组数据存在的
        // 那么只需要考虑辅助数组左侧的数据没有全部填入原数组的情况
        if (left<=mid) {
            while(left<=mid){
                arr[current] = helper[left];
                current++;
                left++;
            }
        }
        
    }

}