Ordenación de arrays en Swift: impactantes pruebas de rendimiento

Swift Beta Performance: Ordenación de arrays — ¿qué salió mal?

Si alguna vez visitaste Stack Overflow en la época de las primeras versiones beta de Swift, seguramente recuerdas la pregunta legendaria que acumuló miles de visitas y cientos de comentarios. Sonaba más o menos así: «¿Por qué la ordenación de arrays en Swift Beta funciona 100 veces más lento que en Objective-C?»

En aquel entonces, en 2014, fue un verdadero shock para la comunidad iOS. Los desarrolladores, acostumbrados a la ordenación ultrarrápida en Objective-C, de repente veían cómo sus aplicaciones se congelaban sin motivo aparente. Hoy, años después, podemos analizar este problema con calma: entender qué causaba exactamente la lentitud, cómo ha evolucionado Swift y, sobre todo, cómo ordenar arrays correctamente en Swift moderno para no repetir los errores del pasado.

En este artículo no solo repasaremos el error antiguo. Realizaremos nuestras propias pruebas, escribiremos código y descubriremos qué algoritmos de ordenación en Swift son realmente rápidos y cuáles son una trampa para principiantes. ¡Allá vamos!

Breve historia: ¿qué ocurrió en Swift Beta?

En la primera versión beta de Swift, ordenar un array de 100 000 números enteros podía llevar hasta 20 segundos. En Objective-C, la misma operación se realizaba en 0.2 segundos. ¡Una diferencia de 100 veces! La razón era que el Swift inicial utilizaba una implementación ineficiente del algoritmo de ordenación (Introsort con mala elección del elemento pivote), además de tener problemas de optimización al compilar sin banderas de optimización (-O).

Además, en la versión beta a menudo se activaba el mecanismo de verificación dinámica de límites (bounds checking) en cada acceso al array, lo que añadía una enorme sobrecarga. La conclusión era simple: Swift estaba verde, pero su potencial era enorme.

¿Cómo ordenar arrays en Swift hoy? Mejores prácticas

El Swift moderno (versiones 5.x y posteriores) es un lenguaje maduro. La ordenación de arrays no solo se ha vuelto rápida, sino que es una de las más rápidas entre los lenguajes principales. Analicemos los métodos principales.

1. Método incorporado sort() — el estándar de oro

La forma más simple y recomendada es usar el método sort() (ordenación in situ) o sorted() (devuelve un nuevo array ordenado).

import Foundation\n\nvar numbers = [5, 3, 8, 1, 9, 2]\nnumbers.sort() // ordenación in situ\nprint(numbers) // [1, 2, 3, 5, 8, 9]\n\nlet sortedNumbers = numbers.sorted() // devuelve un nuevo array\nprint(sortedNumbers) // [1, 2, 3, 5, 8, 9]

Internamente, sort() utiliza TimSort — un algoritmo híbrido que funciona en O(n log n) en promedio y O(n) en datos casi ordenados. Es el mismo algoritmo que se usa en Python y Java. Está magníficamente optimizado para procesadores modernos.

2. Ordenación con closure: personalización

Si necesitas ordenar un array en orden descendente o según un criterio complejo, usa un closure:

let words = ["manzana", "naranja", "plátano", "kiwi"]\nlet sortedByLength = words.sorted { $0.count < $1.count }\nprint(sortedByLength) // ["kiwi", "manzana", "plátano", "naranja"]\n\nlet descendingNumbers = numbers.sorted(by: >)\nprint(descendingNumbers) // [9, 8, 5, 3, 2, 1]

Importante: el closure debe ser una función pura (pure function) — sin efectos secundarios. De lo contrario, corres el riesgo de obtener un comportamiento impredecible y una caída en el rendimiento.

3. Ordenación de estructuras personalizadas

Cuando trabajas con tus propios tipos de datos, lo mejor es implementar el protocolo Comparable. Esto te permitirá usar sort() sin closure.

struct Person: Comparable {\n    let name: String\n    let age: Int\n\n    static func < (lhs: Person, rhs: Person) -> Bool {\n        return lhs.age < rhs.age // ordenamos por edad\n    }\n}\n\nle