• 1. merge函數的實現

private static void merge(int[] arr, int low, int mid, int high) {
    // 將要排序的數組片段復制出來
    int[] temp = Arrays.copyOfRange(arr, low, high + 1);
    // 左邊數組的結束索引
    int end1 = mid - low;
    // 右邊數組的結束索引
    int end2 = temp.length - 1;
    // 左邊數組開始歸并的索引
    int i = 0;
    // 右邊數組開始歸并的索引
    int j = end1 + 1;

    for (int k = low; k <= high; k++) {
        if (i > end1) {
            // 左邊數組的歸并指針率先超出了左邊數組的范圍
            // 則直接將右邊剩下的所有數據全部復制過去即可
            arr[k] = temp[j];
            j++;
        } else if (j > end2) {
            // 右邊數組的歸并指針率先超出了右邊數組的范圍
            // 則直接將左邊剩下的所有數據全部復制過去即可
            arr[k] = temp[i];
            i++;
        } else {
            // 正常歸并
            if (temp[i] < temp[j]) {
                arr[k] = temp[i];
                i++;
            } else {
                arr[k] = temp[j];
                j++;
            }
        }
    }
}

• 2. 遞歸方式實現(自頂向下)的歸并排序算法

public static void mergeSort(int[] arr, int low, int high) {
    if (low >= high) {
        return;
    }
    int mid = low + (high - low) / 2;
    mergeSort(arr, low, mid);
    mergeSort(arr, mid + 1, high);
    merge(arr, low, mid, high);
}

• 3. 借用棧實現循環方式(自頂向下)的歸并排序算法

public static void mergeSort2(int[] arr) {
    if (arr.length <= 1) {
        return;
    }
    Stack<Integer> st = new Stack<>();
    int left = 0;
    int right = arr.length - 1;
    int center = left + (right - left) / 2;
    st.push(left);
    st.push(right);
    while (!st.isEmpty()) {
        int high = st.pop();
        int low = st.pop();
        int mid = low + (high - low) / 2;
        if (low < mid) {
            st.push(low);
            st.push(mid);
        }
        if (mid + 1 < high) {
            st.push(mid + 1);
            st.push(high);
        }
        merge(arr, low, mid, high);
    }
    merge(arr, left, center, right);
}

• 4. 不借用棧(自低向上)直接循環方式實現的歸并排序算法
     這種方式可以實現對鏈表進行 Nlog(N)時間復雜度級別的排序

public static void mergeSort3(int[] arr) {
    for (int sz = 1; sz <= arr.length; sz += sz) {
        for (int i = 0; i + sz < arr.length; i += sz + sz) {
            int low = i;
            int mid = i + sz - 1;
            int high = Math.min(i + sz + sz - 1, arr.length - 1);
            merge(arr, low, mid, high);
        }
    }
}