Seleccionar ordenar
introducción básica
La clasificación selectiva también pertenece al método de clasificación interna , que consiste en seleccionar un elemento de los datos que se clasificará de acuerdo con las reglas especificadas y luego intercambiar posiciones de acuerdo con las regulaciones para lograr el propósito de la clasificación.
Ordenar el pensamiento
Seleccionar clasificación también es un método de clasificación simple. Su idea básica es :
La primera vez : Encuentre el valor más pequeño de una matriz e intercambie con la matriz [0], es decir, en lugar de encontrar el más pequeño como burbujear, intercambiar, pero atravesar la matriz, encontrar el más pequeño e intercambiar con matriz [0 ], una vez Solo un intercambio
Segunda vez : Encuentre el valor mínimo de la matriz [1] ~~~ matriz [n-1] de la matriz de la matriz, e intercambie con la matriz [1]. En este proceso, solo ocurre un intercambio.
Tercera vez : la matriz [2] se convierte en el valor mínimo. . . . Y así
Pase un total de n-1 veces para obtener una secuencia ordenada ordenada de pequeña a grande según el código de clasificación
Ideas
La primera ronda: considere la primera posición como el número más pequeño, comience a recorrer las matrices restantes , actualice el valor más pequeño al valor más pequeño y luego busque los más pequeños que el actual. Después de una ronda, encuentre el número más pequeño y empezar a intercambiar
La segunda ronda: considere la segunda posición como el número más pequeño, comience a recorrer las matrices restantes , compare más tarde y descubra que es más pequeña, actualice el valor mínimo y luego, encuentre el número más pequeño de los números restantes. Después del recorrido, Swap con la primera posición.
La tercera ronda: lo mismo, partiendo de la tercera posición
….
Hasta la ronda n-1
Escuche la pregunta:
Estudiantes universitarios de la Sección diez existentes , los valores de color son [100,10,35,24,16,79,4,2,57,80], use la clasificación de selección de menor a mayor para ordenar
Código
El proceso de derivación:
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 21:32
* @Description TODO
* @pojectname 简单选择排序
*/
public class SelectSort {
public static void main(String[] args) {
int[] array = {
100,10,35,24,16,79,4,2,57,80};
selectSort(array);
}
//选择排序算法
public static void selectSort(int[] array){
//逐步推到方式
//第一轮排序
//原始数组[100,10,35,24,16,79,4,2,57,80]
//结果：[2,10,35,24,16,79,4,100,57,80]
int minIndex = 0;//用来存放，最小值的下标
int min = array[0];//假定现在最小值是数组第一个 也充当了中间值，来交换
for (int i = 0+1; i < array.length ; i++) {
if (min > array[i]){
//说明我们的假定最小值不是最小值
min = array[i]; //重置最小值
minIndex = i; //重置最小值索引
}
}
//循环结束，开始交换
if (minIndex != 0) {
array[minIndex] = array[0];
array[0] = min;
}
System.out.println("第一轮后："+ Arrays.toString(array));
//第一轮后：[2, 10, 35, 24, 16, 79, 4, 100, 57, 80]
//第二轮排序
minIndex = 1;//用来存放，最小值的下标
min = array[1];//假定现在最小值是数组第一个 也充当了中间值，来交换
for (int i = 1+1; i < array.length ; i++) {
if (min > array[i]){
//说明我们的假定最小值不是最小值
min = array[i]; //重置最小值
minIndex = i; //重置最小值索引
}
}
//循环结束，开始交换
if (minIndex != 1) {
array[minIndex] = array[1];
array[1] = min;
}
System.out.println("第二轮后："+ Arrays.toString(array));
//第二轮后：第二轮后：[2, 4, 35, 24, 16, 79, 10, 100, 57, 80]
//依次类推
}
}
En el proceso de derivación, encontramos que antes de cada uno de nuestros bucles for, la marca de inicio es +1 que la posición inicial del bucle for anterior.
Entonces podemos usar un bucle for para resolver
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 21:32
* @Description TODO
* @pojectname 简单选择排序
*/
public class SelectSort {
public static void main(String[] args) {
int[] array = {
100,10,35,24,16,79,4,2,57,80};
System.out.println("排序前"+Arrays.toString(array));
selectSort(array);
System.out.println("排序后"+Arrays.toString(array));
}
//选择排序算法
public static void selectSort(int[] array){
for (int i = 0; i < array.length -1 ; i++) {
int minIndex = i;
int min = array[i];
for (int j = i+1; j <array.length ; j++) {
if (min > array[j]){
//说明假定的最小值不是最小
min = array[j];//重置min
minIndex = j;//重置最小值下标
}
}
//交换
if (minIndex != i){
array[minIndex] = array[i];
array[i] = min;
}
System.out.println("第"+i+"轮排序的结果是");
System.out.println(Arrays.toString(array));
}
}
}
Profundicemos la memoria con el lenguaje:
El ciclo externo controla la primera ronda de clasificación, y el ciclo interno se usa para controlar dónde comienza nuestra clasificación.
Entre ellos, ¿cuáles son las ventajas? Descubrimos que nuestro método de intercambio de datos es diferente de nuestra clasificación de burbujas, porque se trata de un intercambio, a diferencia de nuestra clasificación de burbujas, intercambiamos cada vez que cumplimos con los requisitos, por lo que nuestra clasificación de elección utiliza la más pequeña El índice de valor es una variable auxiliar intermedia utilizada para cambiar solo una vez
Entonces, algunas personas pensarían, ¿qué pasa si no tengo que negociar en la enésima ronda? Descubrimos que hay una capa adicional de juicio if cuando intercambiamos . Esto si el juicio se usa para juzgar si el subíndice mínimo actual es el subíndice del valor mínimo que asumimos al principio . Si no está intercambiando, se generará directamente., No se produce ningún intercambio, que es una pequeña optimización
Luego medimos el tiempo para seleccionar ordenar para ordenar una matriz [80000] matriz, descubrimos que solo 2 segundos o 3 segundos , de hecho es mucho más rápido que la ordenación de burbujas