Summary: Merge Sort of Array && 求逆序对

常用算法（后面有inplace版本）：

package ArrayMergeSort;

import java.util.Arrays;

public class Solution {
    public int[] mergeSort(int[] arr) {
        if (arr.length == 1) return arr;
        else {
            int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length/2);
            int[] arr2 = Arrays.copyOfRange(arr, arr.length/2, arr.length);
            return merge(mergeSort(arr1), mergeSort(arr2));
        }
    }
    
    public int[] merge(int[] arr1, int[] arr2) {
        int len1 = arr1.length;
        int len2 = arr2.length;
        int[] res = new int[len1+len2];
        int i = 0, j=0, cur=0;
        while (i<len1 && j<len2) {
            if (arr1[i] <= arr2[j]) {
                res[cur++] = arr1[i++];
            }
            else {
                res[cur++] = arr2[j++];
            }
        }
        while (i<len1) {
            res[cur++] = arr1[i++];
        }
        while (j<len2) {
            res[cur++] = arr2[j++];
        }
        return res;
    }
    
    

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Solution sol = new Solution();
        int[] arr = sol.mergeSort(new int[]{6,5,4,8,2,1});
        System.out.println(Arrays.toString(arr));
    }

}

 在如上算法中只需稍作修改，加上一行代码，就可以求数组的逆序对

如数组 <2,3,8,6,1> 的逆序对为：<2,1> <3,1> <8,6> <8,1> <6,1> 共5个逆序对。

暴力法是O（N^2）

mergeSort可以O（NlogN）

定义一个static variable count, 然后在12行加入

public int[] merge(int[] arr1, int[] arr2) {
        int len1 = arr1.length;
        int len2 = arr2.length;
        int[] res = new int[len1+len2];
        int i = 0, j=0, cur=0;
        while (i<len1 && j<len2) {
            if (arr1[i] <= arr2[j]) {
                res[cur++] = arr1[i++];
            }
            else { // arr1[i] > arr2[j];
                res[cur++] = arr2[j++];
                count += arr1.length - i;
            }
        }
        while (i<len1) {
            res[cur++] = arr1[i++];
        }
        while (j<len2) {
            res[cur++] = arr2[j++];
        }
        return res;
    }

Inplace的mergeSort不是那么好写，我还是在merge的时候用了额外空间

package ArrayMergeSort;

import java.util.Arrays;

public class Solution2 {
    
    public int[] mergeSort(int[] arr) {
        if (arr==null || arr.length==0) return arr;
        mergeSort(arr, 0, arr.length-1);
        return arr;
    }
    
    public void mergeSort(int[] arr, int l, int r) {
        if (r-l == 0) return;
        int m = (l+r)/2;
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        merge(arr, l, m, m+1, r);
    }
    
    public void merge(int[] arr, int l1, int r1, int l2, int r2) {
        int[] temp = new int[r2-l1+1];
        int i1=l1, i2=l2, cur=0;
        while (i1<=r1 && i2<=r2) {
            if (arr[i1] <= arr[i2]) temp[cur]=arr[i1++];
            else temp[cur] = arr[i2++];
            cur++;
        }
        while(i1<=r1) temp[cur++]=arr[i1++];
        while(i2<=r2) temp[cur++]=arr[i2++];
        cur = 0;
        for (int i=l1; i<=r2; i++) arr[i]=temp[cur++];
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Solution2 sol = new Solution2();
        int[] arr = sol.mergeSort(new int[]{6,5,4,2,1});
        System.out.println(Arrays.toString(arr));
    }

}

 Iterative Merge Sort大致的算法是，假设每一层需要merge许多数组 A和B数组是其中两个，i 可以理解为A或B的size，从1一直到array.length/2. j 可以理解为一组A和B之中B的结束位置。 Merge函数跟上面一样

Iterative Merge Sort
public static T[] Iterative(T[] array, IComparer<T> comparer)
{
    for (int i = 1; i <= array.Length / 2 + 1; i *= 2)
    {
        for (int j = i; j < array.Length; j += 2 * i)
        {
            Merge(array, j - i, j, Math.Min(j + i, array.Length), comparer);
        }
    }
 
    return array;
}