¿Por qué Collections.sort usa Mergesort pero Arrays.sort no?

Estoy usando JDK-8 (x64). Para Arrays.sort(primitivas) encontré lo siguiente en la documentación de Java:

El algoritmo de clasificación es un Quicksort de doble pivote de Vladimir Yaroslavskiy, Jon Bentley y Joshua Bloch.

Para Collections.sort(objetos) encontré este "Timsort":

Esta implementación es un mergesort iterativo, adaptable, estable ... Esta implementación vuelca la lista especificada en una matriz, ordena la matriz e itera sobre la lista restableciendo cada elemento desde la posición correspondiente en la matriz.

Si Collections.sortusa una matriz, ¿por qué no simplemente llama Arrays.sorto usa QuickSort de doble pivote ? ¿Por qué utilizar Mergesort ?

La API garantiza una clasificación estable que Quicksort no ofrece. Sin embargo, al ordenar los valores primitivos por su orden natural, no notará una diferencia ya que los valores primitivos no tienen identidad. Por lo tanto, Quicksort se puede usar para matrices primitivas y se usará cuando se considere más eficiente¹.

En el caso de los objetos, puede observar cuando los objetos con una identidad diferente que se consideran iguales según su equalsimplementación o la proporcionada Comparatorcambian su orden. Por lo tanto, Quicksort no es una opción. Entonces se usa una variante de MergeSort , las versiones actuales de Java usan TimSort . Esto se aplica a ambos Arrays.sorty Collections.sort, aunque con Java 8, el Listmismo puede anular los algoritmos de ordenación.

¹ La ventaja de eficiencia de Quicksort es que necesita menos memoria cuando se realiza en el lugar. Pero tiene un rendimiento dramático en el peor de los casos y no puede explotar las ejecuciones de datos preordenados en una matriz, lo que hace TimSort .

Por lo tanto, los algoritmos de clasificación se modificaron de una versión a otra, mientras permanecían en la clase que ahora tiene un nombre engañoso DualPivotQuicksort. Además, la documentación no se puso al día, lo que muestra que, en general, es una mala idea nombrar un algoritmo utilizado internamente en una especificación, cuando no es necesario.

La situación actual (incluyendo Java 8 a Java 11) es la siguiente:

• Generalmente, los métodos de clasificación para matrices primitivas usarán Quicksort solo bajo ciertas circunstancias. Para arreglos más grandes, intentarán identificar primero las ejecuciones de datos preordenados , como lo hace TimSort , y los fusionará cuando la cantidad de ejecuciones no supere un cierto umbral. De lo contrario, recurrirán al ordenamiento rápido , pero con una implementación que recurrirá al ordenamiento por inserción para rangos pequeños, lo que no solo afecta a las matrices pequeñas, sino también a la recursividad del ordenamiento rápido.
• sort(char[],…)y sort(short[],…)agregue otro caso especial, para usar la clasificación de conteo para matrices cuya longitud exceda un cierto umbral
• Del mismo modo, sort(byte[],…)usará la ordenación por conteo , pero con un umbral mucho más pequeño, lo que crea el mayor contraste con la documentación, ya que sort(byte[],…)nunca usa ordenación rápida. Solo usa la ordenación por inserción para matrices pequeñas y la ordenación por conteo en caso contrario.

No sé acerca de la documentación, pero la implementación de java.util.Collections#sortJava 8 (HotSpot) es así:

@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}

Y List#sorttiene esta implementación:

@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

Entonces, al final, los Collections#sortusos Arrays#sort(de elementos de objeto) detrás de escena. Esta implementación utiliza ordenación por fusión o ordenación por tiempo.

Según el Javadoc, solo las matrices primitivas se ordenan usando Quicksort. Las matrices de objetos también se ordenan con Mergesort.

Por lo tanto, Collections.sort parece usar el mismo algoritmo de clasificación que Arrays.sort para Objetos.

Otra pregunta sería por qué se usa un algoritmo de clasificación diferente para matrices primitivas que para matrices de objetos.

Como se indica en muchas de las respuestas.

Arrays.sort utiliza Quicksort para ordenar colecciones primitivas porque no se requiere estabilidad (no sabrá ni le importará si se intercambiaron dos entradas idénticas en la ordenación)

Arrays.sort usa MergeSort o más específicamente Timsort para ordenar colecciones de objetos. Se requiere estabilidad. Quicksort no proporciona estabilidad, Timsort sí.

Collections.sort delega a Arrays.sort, por lo que ve el javadoc haciendo referencia a MergeSort.

La ordenación rápida tiene dos inconvenientes importantes cuando se trata de la ordenación combinada:

• No es estable mientras que no es primitivo.
• No garantiza el rendimiento de n log n.

La estabilidad no es un problema para los tipos primitivos, ya que no existe una noción de identidad a diferencia de la igualdad (de valores).

La estabilidad es un gran problema al clasificar objetos arbitrarios. Es un buen beneficio adicional que Merge Sort garantiza un rendimiento n log n (tiempo) sin importar la entrada. Es por eso que se selecciona la clasificación por combinación para proporcionar una clasificación estable (clasificación por combinación) para ordenar las referencias de objetos.