主體還是歸并排序，使用插入排序粗化原子任務的葉子節點

public static void main(String[] args) {
    // 構造數據
    Random random =  new Random(System.currentTimeMillis());
    int[] arr = new int[1000000];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = random.nextInt();
    }
    // 測試數組
    int[] arr2 = new int[arr.length];
    // 步長為 5，觀察尋找最優解 k 值, 大部分情況下在100左右出現
    for (int i = 1; i <= 500; i += 5) {
        System.arraycopy(arr, 0, arr2, 0, arr.length);
        long start = System.currentTimeMillis();
        mergeWithInsert(arr2, 0, arr2.length - 1, i);
        long end  = System.currentTimeMillis();
        System.out.println("k:["  + i + "] -> " + (end - start));

    }
}


/**
 *
 * @param arr 數組
 * @param p 起始節點下標
 * @param r 結束節點下標
 * @param k 當 r+1-q <= k 時，不再分解問題，直接使用insert解決問題
 */
public static void mergeWithInsert(int[] arr, int p, int r, int k) {
    if (p < r) {
        // 步長小于k, 則直接采用插入排序, 制造粗葉子節點
        if ((r + 1 - p) <= k) {
            insertionSort(arr, p, r);
        } else {
            // 計算q，分組
            int q = (p + r) / 2;
            // 排序左邊
            mergeWithInsert(arr, p, q, k);
            // 排序右邊
            mergeWithInsert(arr, q + 1, r,  k);
            // 合并左右結果
            merge(arr, p, q, r);
        }
    }
}

/**
 * arr 原始數組, 不使用哨兵牌，判斷條件改為i,j兩個索引必須同時小于各自數組的長度
 * @param arr 原始數組
 * @param p 當前Left分組的起始點下標
 * @param q 當前中間節點下標
 * @param r 當前Right分組的結束點下標
 */
public static void merge(int[] arr, int p, int q, int r) {
    // 計算兩個分組的長度
    int n1 = q - p + 1;
    int n2 = r - q;
    // 復制原數組對應端的數據到兩個新的分組
    int[] lArr = new int[n1];
    int[] rArr = new int[n2];
    System.arraycopy(arr, p, lArr, 0, n1);
    System.arraycopy(arr, q + 1, rArr, 0, n2);
    // 開始排序
    int i = 0, j = 0, k;
    // 遍歷當前排序區間
    for (k = p; i < n1 && j < n2; k++) {
        // 左側拿牌
        if (lArr[i] <= rArr[j]) {
            arr[k] = lArr[i];
            i++;
        } else { // 右側拿牌
            arr[k] = rArr[j];
            j++;
        }
    }
    // 拿未拿完的堆的牌到排序堆頂
    if (i == n1) {
        System.arraycopy(rArr, j,arr, k, n2  - j);
    } else {
        System.arraycopy(lArr, i,arr, k, n1  - i);
    }
    // 打印每一次merge的結果
    // System.out.println(Arrays.toString(arr));
}


private static void insertionSort(int[] arr, int p, int r) {
    int i;
    for (int j = p + 1; j <= r; j++) {
        i = j - 1;
        int key = arr[j];
        while (i >= p && arr[i] > key) {
            arr[i + 1] = arr[i];
            i = i - 1;
        }
        arr[i + 1] = key;
    }
}