Orden de selección es un algoritmo de clasificación simple y eficiente que funciona seleccionando repetidamente el elemento más pequeño (o más grande) de la parte no ordenada de la lista y moviéndolo a la parte ordenada de la lista.

El algoritmo selecciona repetidamente el elemento más pequeño (o más grande) de la parte no ordenada de la lista y lo intercambia con el primer elemento de la parte no ordenada. Este proceso se repite para la parte restante sin ordenar hasta que se ordene toda la lista.

¿Cómo funciona el algoritmo de clasificación por selección?

Consideremos la siguiente matriz como ejemplo: arreglo[] = {64, 25, 12, 22, 11}

Primer pase:

• Para la primera posición en la matriz ordenada, toda la matriz se recorre desde el índice 0 al 4 secuencialmente. La primera posición donde 64 está almacenado actualmente, después de recorrer toda la matriz, está claro que 11 es el valor más bajo.
• Por lo tanto, reemplace 64 con 11. Después de una iteración 11 , que resulta ser el valor menor de la matriz, tiende a aparecer en la primera posición de la lista ordenada.

Algoritmo de clasificación de selección | Intercambiando el primer elemento con el mínimo en la matriz

Segundo pase:

• Para la segunda posición, donde está presente 25, recorra nuevamente el resto de la matriz de manera secuencial.
• Después de recorrer, encontramos que 12 es el segundo valor más bajo de la matriz y debería aparecer en el segundo lugar de la matriz, por lo tanto intercambie estos valores.

Algoritmo de clasificación de selección | intercambiando i=1 con el siguiente elemento mínimo

Tercer pase:

• Ahora, por el tercer lugar, donde 25 está presente nuevamente, recorra el resto de la matriz y encuentre el tercer valor menor presente en la matriz.
• Mientras atraviesa, 22 resultó ser el tercer valor menor y debería aparecer en el tercer lugar de la matriz, por lo que se intercambia 22 con elemento presente en la tercera posición.

Algoritmo de clasificación de selección | intercambiando i=2 con el siguiente elemento mínimo

Cuarto pase:

• De manera similar, para la cuarta posición, recorra el resto de la matriz y encuentre el cuarto elemento menor en la matriz.
• Como 25 es el cuarto valor más bajo, por lo tanto, se ubicará en la cuarta posición.

Algoritmo de clasificación de selección | intercambiando i=3 con el siguiente elemento mínimo

Quinto pase:

• Por fin, el valor más grande presente en la matriz se coloca automáticamente en la última posición de la matriz.
• La matriz resultante es la matriz ordenada.

Algoritmo de clasificación de selección | Matriz ordenada requerida

A continuación se muestra la implementación del enfoque anterior:

// C++ program for implementation of // selection sort #include  using namespace std; // Function for Selection sort void selectionSort(int arr[], int n) {  int i, j, min_idx;  // One by one move boundary of  // unsorted subarray  for (i = 0; i < n - 1; i++) {  // Find the minimum element in  // unsorted array  min_idx = i;  for (j = i + 1; j < n; j++) {  if (arr[j] < arr[min_idx])  min_idx = j;  }  // Swap the found minimum element  // with the first element  if (min_idx != i)  swap(arr[min_idx], arr[i]);  } } // Function to print an array void printArray(int arr[], int size) {  int i;  for (i = 0; i < size; i++) {  cout << arr[i] << ' ';  cout << endl;  } } // Driver program int main() {  int arr[] = { 64, 25, 12, 22, 11 };  int n = sizeof(arr) / sizeof(arr[0]);  // Function Call  selectionSort(arr, n);  cout << 'Sorted array: 
';  printArray(arr, n);  return 0; } // This is code is contributed by rathbhupendra>

// C program for implementation of selection sort #include  void swap(int *xp, int *yp) {  int temp = *xp;  *xp = *yp;  *yp = temp; } void selectionSort(int arr[], int n) {  int i, j, min_idx;  // One by one move boundary of unsorted subarray  for (i = 0; i < n-1; i++)  {  // Find the minimum element in unsorted array  min_idx = i;  for (j = i+1; j < n; j++)  if (arr[j] < arr[min_idx])  min_idx = j;  // Swap the found minimum element with the first element  if(min_idx != i)  swap(&arr[min_idx], &arr[i]);  } } /* Function to print an array */ void printArray(int arr[], int size) {  int i;  for (i=0; i < size; i++)  printf('%d ', arr[i]);  printf('
'); } // Driver program to test above functions int main() {  int arr[] = {64, 25, 12, 22, 11};  int n = sizeof(arr)/sizeof(arr[0]);  selectionSort(arr, n);  printf('Sorted array: 
');  printArray(arr, n);  return 0; }>

// Java program for implementation of Selection Sort import java.io.*; public class SelectionSort {  void sort(int arr[])  {  int n = arr.length;  // One by one move boundary of unsorted subarray  for (int i = 0; i < n-1; i++)  {  // Find the minimum element in unsorted array  int min_idx = i;  for (int j = i+1; j < n; j++)  if (arr[j] < arr[min_idx])  min_idx = j;  // Swap the found minimum element with the first  // element  int temp = arr[min_idx];  arr[min_idx] = arr[i];  arr[i] = temp;  }  }  // Prints the array  void printArray(int arr[])  {  int n = arr.length;  for (int i=0; i

# Python program for implementation of Selection # Sort A = [64, 25, 12, 22, 11] # Traverse through all array elements for i in range(len(A)-1): # Find the minimum element in remaining  # unsorted array min_idx = i for j in range(i+1, len(A)): if A[min_idx]>A[j]: min_idx = j # Intercambia el elemento mínimo encontrado con # el primer elemento A[i], A[min_idx] = A[min_idx], A[i] # Código del controlador para probar arriba print ('Matriz ordenada ') para i en el rango(len(A)): print(A[i],end=' ')>

// C# program for implementation  // of Selection Sort using System; class GFG {   static void sort(int []arr)  {  int n = arr.Length;  // One by one move boundary of unsorted subarray  for (int i = 0; i < n - 1; i++)  {  // Find the minimum element in unsorted array  int min_idx = i;  for (int j = i + 1; j < n; j++)  if (arr[j] < arr[min_idx])  min_idx = j;  // Swap the found minimum element with the first  // element  int temp = arr[min_idx];  arr[min_idx] = arr[i];  arr[i] = temp;  }  }  // Prints the array  static void printArray(int []arr)  {  int n = arr.Length;  for (int i=0; i

>

 // PHP program for implementation  // of selection sort  function selection_sort(&$arr, $n) { for($i = 0; $i < $n ; $i++) { $low = $i; for($j = $i + 1; $j < $n ; $j++) { if ($arr[$j] < $arr[$low]) { $low = $j; } } // swap the minimum value to $ith node if ($arr[$i]>$arr[$bajo]) { $tmp = $arr[$i]; $arr[$i] = $arr[$bajo]; $arr[$bajo] = $tmp; } } } // Código del controlador $arr = array(64, 25, 12, 22, 11); $len = contar($arr); selección_sort($arr, $len); echo 'Matriz ordenada: 
'; para ($i = 0; $i< $len; $i++) echo $arr[$i] . ' '; // This code is contributed  // by Deepika Gupta.  ?>>

Sorted array: 11 12 22 25 64>

Análisis de complejidad del tipo de selección

Complejidad del tiempo: La complejidad temporal de la clasificación por selección es EN ² ) ya que hay dos bucles anidados:

• Un bucle para seleccionar un elemento de Array uno por uno = O(N)
• Otro bucle para comparar ese elemento con todos los demás elementos del Array = O(N)
• Por lo tanto, complejidad general = O(N) * O(N) = O(N*N) = O(N²)

Espacio Auxiliar: O(1) ya que la única memoria adicional utilizada es para variables temporales mientras se intercambian dos valores en Array. La clasificación por selección nunca realiza más que intercambios O(N) y puede resultar útil cuando la escritura en memoria es costosa.

pruebas de rendimiento

Ventajas del algoritmo de clasificación por selección

• Simple y fácil de entender.
• Funciona bien con pequeños conjuntos de datos.

Desventajas del algoritmo de clasificación por selección

• La clasificación por selección tiene una complejidad temporal de O (n^2) en el peor y promedio de los casos.
• No funciona bien en grandes conjuntos de datos.
• No conserva el orden relativo de elementos con claves iguales, lo que significa que no es estable.

Preguntas frecuentes sobre la clasificación por selección

P1. ¿Es estable el algoritmo de clasificación por selección?

La implementación predeterminada del algoritmo de clasificación por selección es no es estable . Sin embargo, se puede estabilizar. Por favor vea el Orden de selección estable para detalles.

P2. ¿Está implementado el algoritmo de clasificación por selección?

Sí, el algoritmo de ordenación por selección es un algoritmo local, ya que no requiere espacio adicional.