Estaba trabajando en la implementación de un quicksort ayer, y luego lo ejecuté, esperando un tiempo de ejecución más rápido que el Mergesort (que también había implementado). Ejecuté los dos, y aunque el quicksort fue más rápido para conjuntos de datos más pequeños < 100 elementos (y I hizo verifican que funciona), el mergesort se convirtió rápidamente en el algoritmo más rápido. Me habían enseñado que el quicksort es casi siempre "más rápido" que mergesort, y entiendo que haya algún debate sobre este tema, pero al menos esperaba que fuera más cercano. Para conjuntos de datos> 10000 elementos, el mergesort fue más de 4 veces más rápido. ¿Es esto esperado, o hay un error en mi código quicksort?Quicksort más lento que Mergesort?
mergesort:
public static void mergeSort(int[ ] e)
{
if (e.length <= 1) return;
int[] first = new int[e.length/2];
int[] second = new int[e.length - first.length];
System.arraycopy(e, 0, first, 0, first.length);
System.arraycopy(e, first.length, second, 0, second.length);
mergeSort(first);
mergeSort(second);
System.arraycopy(merge(first, second), 0, e, 0, e.length);
}
private static int[] merge(int[] first, int[] second) {
int iFirst = 0;
int iSecond = 0;
int iCombined = 0;
int[] combined = new int[first.length + second.length];
while(iFirst < first.length && iSecond < second.length) {
if (first[iFirst] > second[iSecond]) {
combined[iCombined++] = second[iSecond++];
}
else combined[iCombined++] = first[iFirst++];
}
for(; iFirst < first.length; iFirst++) {
combined[iCombined++] = first[iFirst];
}
for(; iSecond < second.length; iSecond++) {
combined[iCombined++] = second[iSecond];
}
return combined;
}
clasificación rápida:
public static void quicksort(int[] a, int first, int last) {
if (first >= last) return;
int partitionIndex = partition(a, first, last);
quicksort(a, first, partitionIndex - 1);
quicksort(a, partitionIndex + 1, last);
}
public static int partition(int[] x, int first, int last) {
int left = first;
int right = last;
int pivot = x[first];
int pivotIdx = first;
while(left <= right) {
while(left < x.length && x[left] <= pivot) left++;
while(right >= 0 && x[right] > pivot) right--;
if (left <= right) {
int temp = x[left];
x[left] = x[right];
x[right] = temp;
}
}
pivotIdx = right;
x[first] = x[right];
x[pivotIdx] = pivot;
return pivotIdx;
}
No, no lo son. Un quicksort sin errores es mucho más rápido. –
@Stephan Eggermont: ¿Puedes señalar los errores en la implementación de John? – Giorgio
ver mi respuesta arriba –