Funcionamiento del Algoritmo

  1. Buscar el elemento mínimo de la lista.
  2. Intercambiarlo con el primer elemento.
  3. Buscar el elemento mínimo del resto de la lista.
  4. Intercambiarlo con el segundo elemento.
  5. Repetir este proceso hasta que la lista esté ordenada.

Ejemplo

Posición inicial:

La flecha indica la posición donde se buscará el elemento mínimo y se pasará a la primera posición. Luego, se avanza una posición más y se repite el proceso.

    ↓
| 4 | 3 | 1 | 5 | 2 |
  0   1   2   3   4

Paso 1:
Buscar el mínimo en la lista completa y moverlo a la primera posición.

    ↓
| 1 | 3 | 4 | 5 | 2 |
  0   1   2   3   4

Paso 2:
Buscar el mínimo en el subarray restante y moverlo a la segunda posición.

        ↓
| 1 | 2 | 4 | 5 | 3 |
  0   1   2   3   4

Paso 3:
Buscar el mínimo en el subarray restante y moverlo a la tercera posición.

            ↓
| 1 | 2 | 3 | 5 | 4 |
  0   1   2   3   4

Paso 4:
Buscar el mínimo en el subarray restante y moverlo a la cuarta posición.

                ↓
| 1 | 2 | 3 | 4 | 5 |
  0   1   2   3   4

Lista Ordenada:

| 1 | 2 | 3 | 4 | 5 |
  0   1   2   3   4

Implementación en C++

Aquí tienes la implementación del algoritmo de Ordenamiento por Selección en C++:

// Ordenamiento por Selección
#include<iostream>
#include<conio.h>

using namespace std;

int main() {
    int numeros[] = {3, 2, 1, 5, 4};
    int n = 5; // Tamaño del array
    int aux, min;

    // Algoritmo del Ordenamiento por Selección
    for (int i = 0; i < n - 1; i++) {
        min = i; // Inicialmente, el mínimo es el primer elemento no ordenado
        for (int j = i + 1; j < n; j++) {
            if (numeros[j] < numeros[min]) {
                min = j; // Encontrar el índice del mínimo elemento
            }
        }
        // Intercambiar el elemento mínimo con el primer elemento no ordenado
        aux = numeros[i];
        numeros[i] = numeros[min];
        numeros[min] = aux;
    }

    // Imprimir array ordenado en orden ascendente
    cout << "Orden Ascendente: \n";
    for (int i = 0; i < n; i++) {
        cout << numeros[i] << " ";
    }

    cout << "\nOrden Descendente: \n";
    for (int i = n - 1; i >= 0; i--) {
        cout << numeros[i] << " ";
    }

    getch();
    return 0;
}

Notas

  • Eficiencia: La complejidad temporal es $O(n^2)$, lo que hace que este algoritmo no sea adecuado para listas grandes.
  • Aplicación: Es útil para conjuntos de datos pequeños o cuando se necesita un algoritmo fácil de implementar y entender.