clasificación de selección
idea de algoritmo
Pasos para seleccionar el orden:
1> Primero encuentre el elemento más pequeño (más grande) en la secuencia sin ordenar y guárdelo al comienzo de la secuencia ordenada.
2> Continúe buscando el elemento más pequeño (el más grande) de los elementos sin clasificar restantes y luego colóquelo en la posición inicial de la secuencia sin clasificar.
3> Repite el segundo paso hasta ordenar todos los elementos.
animación
código de algoritmo
public static void selectSort1(int[] a){
for (int i = 0; i < a.length; i++) {
int minIndex = i;
for (int j = i+1 ; j <a.length ; j++) {
if(a[j] <= a[minIndex]){
minIndex = j;
}
}
if(minIndex == i) continue; //说明没找到更小的
int tmp = a[minIndex];
a[minIndex] = a[i];
a[i] = tmp;
}
}Análisis de Complejidad
Complejidad temporal O(n^2) Secuencia aritmética
Complejidad espacial O(1)
Estabilidad Inestable
optimización de clasificación de selección
La idea de optimización de la clasificación por selección es generalmente encontrar los valores máximo y mínimo al mismo tiempo en un recorrido y colocarlos en ambos extremos de la matriz, de modo que el número de recorridos se pueda reducir a la mitad. La primera vez para seleccionar el valor máximo y el valor mínimo, el proceso es el siguiente:
código de algoritmo
public static void selectSort2(int[] a){
int left = 0;
int right = a.length-1;
while(left<right) {
int minIndex = left;
int maxIndex = right;
for(int i = left+1;i<=right;i++) {
if(a[i] < a[minIndex]) {
minIndex = i;
}
if(a[i] > maxIndex) {
maxIndex = i;
}
}
//交换左边
int tmp1 = a[minIndex];
a[minIndex] = a[left];
a[left] = tmp1;
if(maxIndex == left) { //很重要的一点细节
maxIndex = minIndex;
}
//交换右边
int tmp2 = a[maxIndex];
a[maxIndex] = a[right];
a[right] = tmp2;
left++;
right--;
}
}prueba de complejidad temporal
A continuación, intentemos probarlo con una gran cantidad de datos.
int[] a = new int[10_0000]; //prueba de 100.000 datos
1. La función orderArray se implementa para generar una secuencia ordenada básica, es decir, ordenada de menor a mayor.
public static void orderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
}2. La función notOrderArray genera una secuencia inversa, es decir, ordenada de mayor a menor.
public static void notOrderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = a.length-i;
}
}3. La función randomArray genera una matriz desordenada aleatoria.
public static void randomArray(int[] a) {
Random random = new Random();
for (int i = 0; i < a.length; i++) {
a[i] = random.nextInt(10_0000);
}
}4. La función testInsertSort prueba el valor de retorno de System.currentTimeMillis() en milisegundos.
public static void testInsertSort(int[] a){
int[] tmpArray = Arrays.copyOf(a,a.length);
long startTime = System.currentTimeMillis(); //注意用long接收
shellSort(tmpArray);
long endTime = System.currentTimeMillis(); //返回单位是毫秒
System.out.println("选择排序耗时："+(endTime-startTime));
}5. Ejecución de la llamada a la función principal
public static void main(String[] args) {
int[] a = new int[10_0000];
//有序
System.out.println("基本有序数列");
orderArray(a);
testInsertSort(a);
//倒序
System.out.println("逆序数列");
notOrderArray(a);
testInsertSort(a);
//随机乱序
System.out.println("无序数列");
randomArray(a);
testInsertSort(a);
}Resultados de la prueba
A partir de los resultados, para una gran cantidad de datos, el optimizado es más lento. Debería ser que este algoritmo de clasificación es más adecuado para una pequeña cantidad de datos.
Ponemos 250 datos para probar.
Los resultados muestran que el consumo de tiempo aún se reduce.
código completo
import java.util.Random;
public class sort {
public static void main(String[] args) {
int[] a = new int[10_0000];
//有序
System.out.println("基本有序数列");
orderArray(a);
testInsertSort(a);
//无序
System.out.println("逆序数列");
notOrderArray(a);
testInsertSort(a);
//乱序
System.out.println("无序数列");
randomArray(a);
testInsertSort(a);
}
public static void selectSort(int[] a){
for (int i = 0; i < a.length; i++) {
int minIndex = i;
for (int j = i+1 ; j <a.length ; j++) {
if(a[j] <= a[minIndex]){
minIndex = j;
}
}
if(minIndex == i) continue; //说明没找到更小的
int tmp = a[minIndex];
a[minIndex] = a[i];
a[i] = tmp;
}
}
//生成有序数组 从小到大排列
public static void orderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
}
//n无序 其实就是从大到小排列
public static void notOrderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = a.length-i;
}
}
//乱序 随机生成序列
public static void randomArray(int[] a) {
Random random = new Random();
for (int i = 0; i < a.length; i++) {
a[i] = random.nextInt(10_0000);
}
}
//大量数据测试
public static void testInsertSort(int[] a){
int[] tmpArray = Arrays.copyOf(a,a.length);
long startTime = System.currentTimeMillis(); //注意用long接收
selectSort(tmpArray);
long endTime = System.currentTimeMillis();
System.out.println("选择排序耗时："+(endTime-startTime));
}
}