為什么遞歸MergeSort比迭代MergeSort更快？

Question

我剛剛實現了這兩種算法，當我繪制結果時我很驚訝！ 遞歸實現顯然比迭代實現快。 之后，我添加了插入排序和兩者，結果是一樣的。

在講座中，我們使用看到遞歸在迭代中比在因子計算中慢，但在這里似乎並非如此。 我很確定我的代碼是正確的。 這種行為的言論是什么？ 看起來java（10）在遞歸模式下自動實現多線程，因為當我顯示小動畫時，插入排序與合並操作並行工作。

如果這些代碼不足以理解這里是我的github： Github

EDIT RELOADED如評論中所述，我應該比較類似的東西，所以現在合並方法在迭代和遞歸中是相同的。

private void merge(ArrayToSort<T> array, T[] sub_array,
                   int min, int mid, int max) {
    //we make a copy of the array.
    if (max + 1 - min >= 0) System.arraycopy(array.array, min, sub_array, min, max + 1 - min);

    int i = min, j = mid + 1;

    for (var k = min; k <= max; k++) {

        if (i > mid) {
            array.array[k] = sub_array[j++];
        } else if (j > max) {
            array.array[k] = sub_array[i++];
        } else if (sub_array[j].compareTo(sub_array[i]) < 0) {
            array.array[k] = sub_array[j++];
        } else {
            array.array[k] = sub_array[i++];
        }
    }
}

遞歸排序：

public void Sort(ArrayToSort<T> array) {
    T sub[] = (T[]) new Comparable[array.Length];
    sort(array, sub, 0, array.Length - 1);
}

private InsertionSort<T> insertionSort = new InsertionSort<>();
private void sort(ArrayToSort<T> array, T[] sub_array, int min, int max) {
    if (max <= min) return;
    if (max <= min + 8 - 1) {
        insertionSort.Sort(array, min, max);
        return;
    }
    var mid = min + (max - min) / 2;
    sort(array, sub_array, min, mid);
    sort(array, sub_array, mid + 1, max);
    merge(array, sub_array, min, mid, max);

}

迭代排序：

private InsertionSort<T> insertionSort = new InsertionSort<>();
public void Sort(ArrayToSort<T> array) {

    int length = array.Length;
    int maxIndex = length - 1;

    T temp[] = (T[]) new Comparable[length];

    for (int i = 0; i < maxIndex; i += 8) {
        insertionSort.Sort(array, i, Integer.min(i + 8 - 1, maxIndex));
    }

    System.arraycopy(array.array, 0, temp, 0, length);

    for (int m = 8; m <= maxIndex; m = 2 * m) {
        for (int i = 0; i < maxIndex; i += 2 * m) {

            merge(array, temp, i, i + m - 1,
                    Integer.min(i + 2 * m - 1, maxIndex));
        }
    }
}

在新的情節中，我們可以看到現在的差異是成比例的（ 非業余的 ）。 如果有人有更多的想法...非常感謝:)
新的*新情節

這是我的（老師的一個事實）方法繪制：

for (int i = 0; i < nbSteps; i++) {
    int N = startingCount + countIncrement * i;
    for (ISortingAlgorithm<Integer> algo : algorithms) {

        long time = 0;
        for (int j = 0; j < folds; j++) {
            ArrayToSort<Integer> toSort = new ArrayToSort<>(
                    ArrayToSort.CreateRandomIntegerArray(N, Integer.MAX_VALUE, (int) System.nanoTime())
            );
            long startTime = System.currentTimeMillis();
            algo.Sort(toSort);
            long endTime = System.currentTimeMillis();
            time += (endTime - startTime);
            assert toSort.isSorted();
        }
        stringBuilder.append(N + ", " + (time / folds) + ", " + algo.Name() + "\n");
        System.out.println(N + ", " + (time / folds) + ", " + algo.Name());
    }

}

Answer 1

我不認為我有答案，因為我沒有嘗試你的代碼。 我會給你一個想法：

a）CPU具有L1緩存和指令預取。 當所有排序完成時，遞歸版本可能具有更好的引用局部性，並且在彈出所有幀時（其他cpu優化原因）完成了一堆合並

b）同時JIT編譯器對遞歸做了瘋狂的事情，特別是由於尾遞歸和內聯。 我建議你試試沒有JIT編譯器只是為了好玩。 也可能想嘗試更改JIT編譯的閾值，因此它可以更快地編譯JIT以最小化預熱時間。

c）system.arraycopy是一種本機方法，盡管經過優化，但它應該有開銷。

d）迭代版似乎在循環中有更多的算術。

e）這是一種微觀基准測試。 你需要將GC分解出來並讓測試運行數十次，甚至數百次。 閱讀JMH。 還可以嘗試不同的GC和-Xmx。