Algorithm learning: (1) merge (2) find the small sum (3) find the number of inverse pairs

table of Contents

1. Merge Sort

2. Xiaohe

3. Descending pairs

---

1. Merge Sort

public class Merge {
    public static void mergeSort(int[] arr,int l,int r){
        if(l==r)    return;
        int mid=l+((r-l)>>1);
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        merge(arr,l,mid,r);
    }

    public static void merge(int[] arr,int l,int m,int r){
        int[] help=new int[r-l+1];
        int index=0;
        int i=l,j=m+1;
        while(i<=m && j<=r){
            help[index++]=arr[i]<=arr[j]?arr[i++]:arr[j++];
        }
        while(i<=m){
            help[index++]=arr[i++];
        }
        while (j<=r){
            help[index++]=arr[j++];
        }
        for (int k = 0; k < help.length; k++) {
            arr[l+k]=help[k];
        }
    }

    public static void mergeSort2(int[] arr){
        int size=arr.length;
        int mergeSize=1;
        while(mergeSize<size){
            int start=0;
            while(start<size){
                int m=start+mergeSize-1;
                if(m>=size)
                    break;
                int r=Math.min(m+mergeSize,size-1);
                merge(arr,start,m,r);
                start=r+1;
            }
            if(mergeSize>size/2)
                break;
            mergeSize<<=1;
        }
    }
}

2. Xiaohe

public class SmallSum {
    public static int smallSum(int[] arr){
        if(arr==null || arr.length<2){
            return 0;
        }
        return  mergeSort(arr,0,arr.length-1);
    }

    public static int mergeSort(int[] arr,int l,int r){
        if(l==r)    return 0;
        int mid=l+((r-l)>>1);
        return mergeSort(arr,l,mid)+
                mergeSort(arr,mid+1,r)+ merge(arr,l,mid,r);
    }

    public static int merge(int[] arr,int l,int m,int r){
        int[] help=new int[r-l+1];
        int index=0;
        int i=l,j=m+1;
        int result=0;//返回的结果

        while(i<=m && j<=r){
            result+=arr[i]<arr[j]?arr[i]*(r-j+1):0;
            help[index++]=arr[i]<arr[j]?arr[i++]:arr[j++];
        }

        while(i<=m){
            help[index++]=arr[i++];
        }
        while (j<=r){
            help[index++]=arr[j++];
        }
        for (int k = 0; k < help.length; k++) {
            arr[l+k]=help[k];
        }
        return result;
    }

    public static void mergeSort2(int[] arr){
        int size=arr.length;
        int mergeSize=1;
        while(mergeSize<size){
            int start=0;
            while(start<size){
                int m=start+mergeSize-1;
                if(m>=size)
                    break;
                int r=Math.min(m+mergeSize,size-1);
                merge(arr,start,m,r);
                start=r+1;
            }
            if(mergeSize>size/2)
                break;
            mergeSize<<=1;
        }
    }

    public static void main(String[] args) {
        int arr[]={1,2,3,4,5,2,3};
        System.out.println(smallSum(arr));
    }
}

3. Descending pairs

    public static int mergeSort(int[] arr, int l, int r) {
        if (l == r) return 0;
        int mid = l + ((r - l) >> 1);
        return mergeSort(arr, l, mid) +
                mergeSort(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    public static int merge(int[] arr, int l, int m, int r) {
        int[] help = new int[r - l + 1];
        int index = 0;
        int i = l, j = m + 1;
        int result = 0;//返回的结果
        while (i <= m && j <= r) {
            if(arr[i]>arr[j])
                result+=(m-i+1);
            
            help[index++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }
        while (i <= m)
            help[index++] = arr[i++];

        while (j <= r)
            help[index++] = arr[j++];

        for (int k = 0; k < help.length; k++)
            arr[l + k] = help[k];

        return result;
    }

    public static void mergeSort2(int[] arr) {
        int size = arr.length;
        int mergeSize = 1;
        while (mergeSize < size) {
            int start = 0;
            while (start < size) {
                int m = start + mergeSize - 1;
                if (m >= size)
                    break;
                int r = Math.min(m + mergeSize, size - 1);
                merge(arr, start, m, r);
                start = r + 1;
            }
            if (mergeSize > size / 2)
                break;
            mergeSize <<= 1;
        }
    }

    public static void main(String[] args) {
        //int arr[] = {1,1,2,2,3,1,1,1,4,4,4,4};
        int arr[]={1,4,5,2,3,1};
        System.out.println(function(arr));
        System.out.println(Arrays.toString(arr));
    }
}

Note the part

            if(arr[i]>arr[j])
                result+=(m-i+1);
            
            help[index++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];

result is not simply +1