【发布时间】：2019-03-25 20:07:23
【问题描述】：
我刚刚实现了这两种算法，当我绘制结果时我很惊讶！递归实现显然比迭代更快。 之后，我加上了两者结合的插入排序，结果是一样的。
在讲座中，我们看到递归比阶乘计算中的迭代慢，但这里似乎并非如此。我很确定我的代码是正确的。 这种行为的解释是什么？看起来java（10）在递归模式下自动实现多线程，因为当我显示插入排序与合并操作并行工作的小动画时。
如果这些代码还不够看懂这里是我的github：Github
已重新加载编辑 正如在 cmets 中所说，我应该比较相似的东西，所以现在合并方法在迭代和递归中是相同的。
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 facteur près）。如果有人有更多的想法......非常感谢:)
新*新剧情
这是我（实际上是老师的）绘制方法：
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());
}
}
【问题讨论】：
-
为什么要在迭代中进行插入排序？
-
这是一个很好的问题，我认为插入小标签会更好。无论如何，在两种算法中都没有插入排序。
-
在您的递归版本中，您使用
System.arraycopy来复制子数组，但在您的迭代版本中，您使用循环来执行此操作。考虑到System.arraycopy是高度优化的，它会比你的循环更快。此外，在迭代版本中，您使用插入排序对 8 元素子数组进行排序，但随后您开始对 4 项子数组进行合并。似乎您应该从 8 项子数组开始。 -
您的
merge方法明显不同，但它们应该相同。不仅循环结构不同，在递归版本中您将temp作为参数传递，而在迭代版本中temp是一个全局变量。仔细检查您的代码，并确保支持函数（如插入排序和合并）是相同的。如果您想了解递归和迭代之间的区别，您必须确保将它们隔离开来。否则，无法确定差异在哪里。 -
您展示的迭代排序方法不会将临时数组传递给
merge方法。迭代排序方法在 temp 中生成数组的完整副本。显然是没有理由的。递归方法不这样做。或者在调用递归版本之前可能会做一些事情。请发布更新，显示您使用的确切代码。包括迭代和递归sort方法和merge方法。另外，请发布您的测试/计时代码，因为可能存在差异。
标签： java algorithm sorting mergesort