¿Es esto un tipo de selección?

Sí lo es. También es muy ineficiente, ya que realizará demasiados intercambios, pero tiene todas las características de un tipo de selección:

  • separa la matriz en dos particiones, una ordenada y otra no;
  • encuentra el elemento mínimo de la partición sin clasificar y lo cambia a la primera posición;
  • mueve el límite de partición en uno hacia arriba;
  • se completa en 0 (n²).

Sin embargo, la selección de selección canónica solo tiene un intercambio por iteración externa:

public static void selectionSort (matriz [int]) {
for (int i = 0; i <array.length – 1; i ++) {
// Encuentra el mínimo en la submatriz sin clasificar.
int min = i;
for (int j = i + 1; j <array.length; j ++) {
if (matriz [min]> matriz [j]) {
min = j;
}
}
// Cambia el mínimo a la primera posición de una submatriz sin clasificar.
// El if es opcional, pero ahorrará tiempo si la matriz es
// ya ordenado
si (i! = min) {
int temp = matriz [i];
matriz [i] = matriz [min];
matriz [min] = temp;
}
}
}

Por supuesto, esto requiere más código y requiere una variable adicional para mantener el mínimo, por lo que si eso es una preocupación por cualquier motivo (hey, a veces todos codificamos en un hardware que tiene 64kB de RAM), su solución es realmente mejor.

El código que figura en los detalles de la pregunta se muestra a continuación.

para (mindex = 0; mindex for (index = mindex + 1; index if (array [mindex]> array [index]) {
swap (matriz [mindex], matriz [índice]);
}
}
}

Este es un tipo de selección.

Un orden de selección se caracteriza por las siguientes dos propiedades:

  1. Las comparaciones son siempre entre elementos sin clasificar (es por eso que se llama un tipo de selección: está seleccionando un elemento de una lista de elementos sin clasificar).
  2. El tamaño de la ventana de comparación disminuye después de cada ciclo.

El programa que se muestra tiene ambas características. Sin embargo, es muy ineficiente , ya que realiza una operación de escritura después de cada comparación, lo cual es innecesario. La operación de escritura debe realizarse solo después de haber pasado por toda la ventana de comparación.

para (mindex = 0; mindex <(longitud - 1); mindex ++)
{
posición = mindex;
para (índice = mindex + 1; índice if (matriz [posición]> matriz [índice])
posición = índice;
if (posición! = mindex)
{
intercambio = matriz [mindex];
array [mindex] = array [posición];
matriz [posición] = intercambio;
}
}

Esta es la versión eficiente de la selección de selección.

Algo así, con muchos intercambios innecesarios.

En el orden de selección, todo lo que necesita hacer es realizar un seguimiento del elemento mínimo en la matriz y en cada iteración intercambiarlo con el elemento en mindex.

para mindex = 1 a arr.lenght – 1
min = mindex

para index = mindex + 1 a arr.length
si arr [índice] min = j;

intercambiar arr [min] y arr [mindex]