Selection Sort Method- Spanish Guide with Examples

¿Qué es el Selection Sort?

Selection Sort es uno de los algoritmos de ordenamiento más simples que existen. No es elegante, no es rápido, pero funciona. Es el tipo de algoritmo que enseñan en universidades porque es fácil de entender, no porque sea la mejor opción para producción.

Básicamente, el algoritmo recorre la lista, encuentra el elemento más pequeño, y lo intercambia con la primera posición. Luego repite el proceso para el resto de elementos. Así hasta que todo está ordenado.

¿Cómo funciona paso a paso?

Imagina que tienes esta lista: [64, 25, 12, 22, 11]

Paso 1: Busca el elemento más pequeño (11) y lo intercambia con la posición 0. Resultado: [11, 25, 12, 22, 64]

Paso 2: Busca el más pequeño desde la posición 1 en adelante (12) y lo intercambia con la posición 1. Resultado: [11, 12, 25, 22, 64]

Paso 3: Busca el más pequeño desde la posición 2 en adelante (22) y lo intercambia con la posición 2. Resultado: [11, 12, 22, 25, 64]

Paso 4: Busca el más pequeño desde la posición 3 en adelante (25) y lo intercambia con la posición 3. Resultado: [11, 12, 22, 25, 64]

Listo. La lista está ordenada. No hizo falta comparar el último elemento porque ya quedó en su lugar.

Implementación en Python

Aquí tienes el código. No tiene trucos, es la versión directa:

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        # Encontrar el índice del mínimo
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        # Intercambiar
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

# Ejemplo de uso
numeros = [64, 25, 12, 22, 11]
print(selection_sort(numeros))

Implementación en JavaScript

function selectionSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        let minIdx = i;
        for (let j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        // Intercambiar
        let temp = arr[i];
        arr[i] = arr[minIdx];
        arr[minIdx] = temp;
    }
    return arr;
}

// Ejemplo
let numeros = [64, 25, 12, 22, 11];
console.log(selectionSort(numeros));

Complejidad del algoritmo

Selection Sort tiene una complejidad de O(n²) en todos los casos. Esto significa que si tienes 1000 elementos, el algoritmo realizará aproximadamente un millón de comparaciones. No mejora si la lista ya está ordenada. No empeora si está desordenada. Siempre hace el mismo trabajo.

La complejidad espacial es O(1) porque solo usa un espacio extra para el intercambio. No importa cuántos elementos haya, siempre necesitas solo una variable temporal.

Comparación con otros algoritmos

No te engañaré. Selection Sort pierde contra casi todos los demás algoritmos de ordenamiento en velocidad. Aquí está la comparación directa:

¿Ves el problema? Selection Sort siempre es O(n²). Los demás algoritmos mejoran significativamente en el mejor caso o en el caso promedio.

¿Cuándo usar Selection Sort?

Honestamente, casi nunca en producción. Pero hay situaciones donde tiene sentido:

• Cuando necesitas ordenar listas muy pequeñas (menos de 10-20 elementos)
• Cuando la memoria es extremadamente limitada
• Cuando quieres un algoritmo de ordenamiento que no usa recursion
• Como paso de aprendizaje antes de pasar a algoritmos más complejos

Si estás ordenando más de 100 elementos, usa Quick Sort, Merge Sort, o simplemente llama a sorted() en Python o .sort() en JavaScript. No reinventes la rueda.

Ventajas y desventajas claras

Ventajas

• Fácil de entender e implementar
• No requiere memoria adicional
• Hace exactamente n intercambios (donde n es el número de elementos)
• Rendimiento predecible: siempre O(n²)

Desventajas

• Lento para listas grandes
• No es estable por defecto (puede cambiar el orden de elementos iguales)
• No aprovecha listas parcialmente ordenadas

Versión estable de Selection Sort

Si necesitas que el algoritmo sea estable (que conserve el orden de elementos iguales), puedes modificarlo así:

def selection_sort_estable(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        # Mover todos los elementos desde min_idx hasta i una posición a la derecha
        key = arr[min_idx]
        k = min_idx
        while k > i:
            arr[k] = arr[k - 1]
            k -= 1
        arr[i] = key
    return arr

Esta versión hace más operaciones de movimiento pero conserva el orden relativo de elementos duplicados. El costo es que ya no tiene O(n) intercambios, sino más.

Resumen rápido

Selection Sort es el algoritmo de ordenamiento que usas cuando estás aprendiendo. No es rápido, no es eficiente, pero es simple. Para cualquier aplicación real, usa las funciones de ordenamiento que ya vienen integradas en tu lenguaje. Para entrevistas técnicas, prepárate para explicarlo, pero no lo uses como tu opción por defecto.