Почему рекурсивный Mergesort быстрее, чем итеративный Mergesort? ⇐ JAVA

[Anonymous]

Я только что внедрил два алгоритма, и я был удивлен, когда я построил результаты! Рекурсивная реализация явно быстрее, чем итеративная. Лекции, которые мы используем, чтобы видеть, что рекурсивный, медленнее, итеративно, как в фактическом расчете, но здесь это не так. Я почти уверен, что мои коды правы. Каково объяснение этого поведения? Br />
Если эти коды недостаточно, чтобы понять, здесь мой GitHub: GitHub < /p>

redit reloaded < /strong>
Как сказано в комментариях, я должен сравнивать вещи, которые похожи, поэтому теперь метод слияния одинаково в итеративном и рекурсивом. < /P>

private void merge(ArrayToSort 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 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) < 0) {
array.array[k] = sub_array[j++];
} else {
array.array[k] = sub_array[i++];
}
}
}
< /code>

Sort Recursive: < /p>

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

private InsertionSort insertionSort = new InsertionSort();
private void sort(ArrayToSort array, T[] sub_array, int min, int max) {
if (max

private InsertionSort insertionSort = new InsertionSort();
public void Sort(ArrayToSort 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

В новом сюжете мы видим, что теперь разница пропорциональна ( à un factor près < /em>). Если у кого -то есть еще какие -нибудь идеи ... Большое спасибо

новый * новый сюжет
< /p>

А вот и мой (один из учителей) метод для участия: < /p>

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

long time = 0;
for (int j = 0; j < folds; j++) {
ArrayToSort 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());
}

}


Подробнее здесь: https://stackoverflow.com/questions/529 ... -mergesort