¿Cuál es el tiempo de ejecución del método sort () en la biblioteca de Colecciones?

No lo sé, y no tengo ganas de leer javadocs hoy.

Así que déjame profundizar en el código fuente …

Google rápido me da esto … 8b04ee324a1a / src / share / classes / java / util /

Es para OpenJDK8 … puede muy bien diferir entre versiones, pero como no ha especificado una versión (o incluso que es Java, aunque supongo que es), eso es lo que utilizaré.

Y aquí está el código:

público estático <T se extiende Comparable > void sort (List list) {
list.sort (nulo);
}

orden público vacío (Comparador c) {
list.sort (c);
}

etc. y un poco más de excavación hace que parezca que la lista es tipo Lista.

Lista lista = Colecciones.synchronizedList (new ArrayList ());

Entonces … ¡nuestro viaje continúa en la clase Lista! Esto es más divertido de lo que esperaba. Debería hacer esta mierda más a menudo.

Aquí estamos:

clasificación nula predeterminada (Comparador c) {
Objeto [] a = this.toArray ();
Arrays.sort (a, (Comparador) c);
ListIterator i = this.listIterator ();
para (Objeto e: a) {
i.next ();
i.set ((E) e);
}
}

Así que lo han pasado a la clase Arrays, como las cosas de apalancamiento perezoso / abstracción que están … a otra clase …

Y aquí vamos:

tipo vacío público estático (int [] a) {
DualPivotQuicksort.sort (a, 0, a.length – 1, nulo, 0, 0);
}

Entonces, alguna versión de QuickSort, aparentemente.

Fui a esa clase, y encontré esto en los comentarios en la parte superior (así como en el algo más adelante):

* Esta clase implementa el algoritmo Quicksort de doble pivote mediante
* Vladimir Yaroslavskiy, Jon Bentley y Josh Bloch. El algoritmo
* ofrece el rendimiento O (n log (n)) en muchos conjuntos de datos que causan otros
* clasificaciones rápidas para degradar a rendimiento cuadrático, y es típicamente
* más rápido que las implementaciones de Quicksort tradicionales (un pivote).

Aparentemente, es una forma avanzada de QuickSort para maximizar el rendimiento.

Y eso es lo que usa la clase Collections en OpenJDK8 … el tiempo de ejecución es O (n log (n)).

En Java 7 y 8 es una ordenación de fusión estable realizada en una matriz con el contenido de la lista volcado en ella (porque no puede fusionar una lista vinculada, pero puede hacerlo en una matriz).

Es importante saber que la implementación puede no ser la misma para todos los tipos de colección y puede cambiar entre las versiones de JVM.

La documentación (y para Java 8) establece:

Nota de implementación: Esta implementación es un mergesort estable, adaptativo e iterativo que requiere mucho menos que n lg (n) comparaciones cuando la matriz de entrada está parcialmente ordenada, al tiempo que ofrece el rendimiento de un mergesort tradicional cuando la matriz de entrada se ordena aleatoriamente. Si la matriz de entrada está casi ordenada, la implementación requiere aproximadamente n comparaciones. Los requisitos de almacenamiento temporal varían desde una pequeña constante para matrices de entrada casi ordenadas hasta n / 2 referencias de objetos para matrices de entrada ordenadas aleatoriamente.

La implementación aprovecha por igual el orden ascendente y descendente en su matriz de entrada, y puede aprovechar el orden ascendente y descendente en diferentes partes de la misma matriz de entrada. Es adecuado para fusionar dos o más matrices ordenadas: simplemente concatene las matrices y clasifique la matriz resultante.

La implementación se adaptó del tipo de lista de Tim Peters para Python ( TimSort ). Utiliza técnicas de “Complejidad teórica de clasificación e información optimista” de Peter McIlroy, en Actas del Cuarto Simposio Anual ACM-SIAM sobre Algoritmos Discretos, pp 467-474, enero de 1993.

Esta implementación volca 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. Esto evita el rendimiento n ^ 2log (n) que resultaría de intentar ordenar una lista vinculada en su lugar.