introducción básica
La clasificación selectiva también es un método de clasificación interna, que consiste en seleccionar un elemento de los datos para 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.
Ideas de selección y clasificación:
Seleccionar clasificación también es un método de clasificación simple. Su idea básica es: primero seleccione el valor mínimo de arr [0] ~ arr [n-1], intercambie con arr [0], y seleccione de arr [1] ~ arr [n-1] por segunda vez El valor mínimo, intercambiar con arr [1], seleccionar el valor mínimo de arr [2] ~ arr [n-1] por tercera vez, intercambiar con arr [2], ..., la i-ésima vez de arr [i-1] ~ Seleccione el valor mínimo de arr [n-1], cámbielo con arr [i-1], ..., seleccione el valor mínimo de arr [n-2] ~ arr [n-1] por enésima vez y cámbielo por arr [n -2] Intercambie, pase n-1 veces en total y obtenga una secuencia ordenada ordenada de pequeña a grande según el código de clasificación.
Seleccione el diagrama de análisis de la idea de clasificación:
Seleccionar y ordenar ejemplos de aplicaciones:
Hay un grupo de vacas, los colores son 101, 34, 119, 1 Utilice el orden de selección para ordenar de menor a mayor [101, 34, 119, 1]
Explicación: Los datos de la eficiencia de la prueba son 80.000, dependiendo del tiempo.
Código
package sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class SelectSort {
public static void main(String[] args) {
//int[] arr = {101, 34, 119, 1,12,43,543};
/*System.out.println("排序前：");
System.out.println(Arrays.toString(arr));
//selectSort1(arr);
selectSort(arr);
System.out.println("排序后：");
System.out.println(Arrays.toString(arr));*/
// 时间测试
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 80000);// 生成一个0-80000的数据
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间为：" + date1Str);
selectSort(arr);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间为：" + date2Str);
}
public static void selectSort(int[] arr) {
// 再推导的过程中，我们发现了规律，因此可以使用循环解决
// 选择排序的时间复杂度也是O(n²)
int minIndex = 0, min = 0;
for (int i = 0; i < arr.length - 1; i++) {
minIndex = i;
min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
// 说明假定的最小值并不是最小值
min = arr[j];
minIndex = j; // 重置min和minIndex
}
}
// 将最小值放在arr[i]的位置，两个值交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
// 选择排序
public static void selectSort1(int[] arr) {
// 使用逐步推导的方式
// 第一轮
// 原原始的数组：101， 34， 119， 1
// 第一轮排序：1， 34， 119， 101
// 算法：先简单→→→再复杂 把一个复杂的问题拆分为多个简单问题
// 第1轮
int minIndex = 0;
int min = arr[0];
for (int i = 0 + 1; i < arr.length; i++) {
if (min > arr[i]) {
// 说明假定的最小值并不是最小值
min = arr[i];
minIndex = i; // 重置min和minIndex
}
}
// 将最小值放在arr[0]的位置，两个值交换
if (minIndex != 0) {
arr[minIndex] = arr[0];
arr[0] = min;
}
System.out.println("第1轮后：");
System.out.println(Arrays.toString(arr));
// 第2轮
minIndex = 1;
min = arr[1];
for (int i = 1 + 1; i < arr.length; i++) {
if (min > arr[i]) {
// 说明假定的最小值并不是最小值
min = arr[i];
minIndex = i; // 重置min和minIndex
}
}
// 将最小值放在arr[1]的位置，两个值交换
// 优化
if (minIndex != 1) {
arr[minIndex] = arr[1];
arr[1] = min;
}
System.out.println("第2轮后：");
System.out.println(Arrays.toString(arr));
// 第3轮
minIndex = 2;
min = arr[2];
for (int i = 2 + 1; i < arr.length; i++) {
if (min > arr[i]) {
// 说明假定的最小值并不是最小值
min = arr[i];
minIndex = i; // 重置min和minIndex
}
}
// 将最小值放在arr[2]的位置，两个值交换
if (minIndex != 2) {
arr[minIndex] = arr[2];
arr[2] = min;
}
System.out.println("第3轮后：");
System.out.println(Arrays.toString(arr));
}
}
En conclusión
80.000 datos tardan entre 2 y 3 segundos, lo que es más rápido que el burbujeo.