归并排序代码实现

描述: 归并排序 - 外部排序（内存有限制，数据无法一次性放入内存，怎么对数据进行排序）
JDK库里面的Java代码，涉及排序都优先采用快排（空间复杂度更好一点）

外部排序的问题(文件的操作)：

现在有50亿个整数，内存限制200M，问你该怎么对这
50亿个整数进行排序？
50亿 = 5G * 4 = 20G

步骤一：先生成100个小文件，每个文件保存一部分数据
大文件里面的整数 % 100 = 小文件的下标

一亿个整数的文件， 内存限制4M
100M * 4 = 400M
1G = 10亿
100M = 1亿

package sort;
import java.util.Arrays;
import java.util.Collections;
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[20];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*100);
        }

    mergeSort(arr, 0, arr.length-1);
    System.out.println(Arrays.toString(arr));
}

/**
 * 实现归并排序
 * @param arr
 * @param i
 * @param j
 */
private static void mergeSort(int[] arr, int i, int j) {
    if(i < j)
    {
        int mid = (i+j)/2;
        /**
         * 以下的操作，先进行数组划分，直到划分为单个元素以后，逐级向上回溯
         * 的时候，进行合并操作
         */
        mergeSort(arr, i, mid);
        mergeSort(arr, mid+1, j);
        merge(arr, i, j); // 合并两个有序的序列
    }
}

/**
 * 合并两个有序的序列
 * @param arr
 * @param low
 * @param high
 */
private static void merge(int[] arr, int low, int high) {
    int[] tmp = new int[high-low+1];
    int mid = (low+high)/2;  // i-mid mid+1-j
    int i=low; // [i, mid]
    int j=mid+1; // [mid+1, high]
    int idx=0;

    // 3 12        5 8
    while(i <= mid && j <= high){
        if(arr[i] > arr[j]){
            tmp[idx++] = arr[j++];
        } else {
            tmp[idx++] = arr[i++];
        }
    }

    while(i <= mid){  //
        tmp[idx++] = arr[i++];
    }

    while(j <= high){
        tmp[idx++] = arr[j++];
    }

    // 把tmp里面合并的有序段再写回arr的[low,high]
    for(int k=low; k<=high; ++k){
        arr[k] = tmp[k-low];
    }
}