web-dev-qa-db-ja.com

なぜ再帰的なMergeSortが反復的なMergeSortより速いのですか？

2つのアルゴリズムを実装したばかりで、結果をプロットしたときに驚きました！再帰的な実装は、反復的な実装よりも明らかに高速です。その後、両方を組み合わせた挿入ソートを追加しましたが、結果は同じでした。

講義では、階乗計算のように反復よりも再帰の方が遅いことを確認するために使用しますが、ここではそうではないようです。私のコードは正しいと確信しています。 この動作の説明は何ですか？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));
        }
    }
}

新しいプロットでは、差異が比例していることがわかります（àun facteurprès）。もし誰かがこれ以上のアイデアを持っているなら...どうもありがとう:)
新しい*新しいプロット iterative vs recursive plot

そして、これがプロットするための私の（実際の教師の）メソッドです：

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());
    }

}
javaalgorithmsortingmergesort
12
Moleson

私はあなたのコードを試さなかったので、答えはないと思います。私はあなたに考えを与えます：

a）CPUにはL1キャッシュと命令プリフェッチがあります。再帰バージョンは、すべてのソートが完了し、（他のCPU最適化の理由で）すべてのフレームをポップしている間に大量のマージで終了している場合、参照の局所性が向上する可能性があります

b）一方、JITコンパイラは、特に末尾再帰とインライン化により、再帰に対しておかしなことをしています。単に楽しみのために、JITコンパイラなしで試すことをお勧めします。また、JITコンパイルのしきい値を変更して、ウォームアップ時間を最小限に抑えるためにJITをより速くコンパイルすることもできます。

c）system.arraycopyはネイティブメソッドであり、最適化されているにもかかわらず、オーバーヘッドが必要です。

d）反復バージョンでは、ループの算術演算が多いようです。

e）それはマイクロベンチマークの試みです。 GCを除外し、テストを数百回ではないにしても数十回実行する必要があります。 JMHについて読んでください。別のGCと-Xmxも試してください。

1
user2023577