Java implementa algoritmos de clasificación de uso común (clasificación de burbuja, clasificación de selección, clasificación de inserción, clasificación de Hill)

Algoritmos de clasificación comunes

Complejidad temporal del algoritmo de clasificación

Algoritmo de clasificación	Tiempo promedio	peor momento	estabilidad	complejidad del espacio	Observación
Ordenamiento de burbuja	En 2)	En 2)	estabilizar	O(1)	mejor cuando n es pequeño
tipo de intercambio	En 2)	En 2)	inestable	O(1) norte	bueno cuando es pequeño
clasificación de selección	En 2)	En 2)	inestable	O(1) norte	bueno cuando es pequeño
tipo de inserción	En 2)	En 2)	estabilizar	O(1)	mayormente en orden
ordenamiento radix	O (negro)	O (negro)	estabilizar	En)	Matriz bidimensional (cubo), matriz unidimensional (posición del primer elemento en el cubo)
clasificación de colinas	O (iniciar sesión)	O(ns)(1<s<2)	inestable	O(1)	s es el grupo seleccionado
ordenación rápida	O (iniciar sesión)	En 2)	inestable	O (inicio de sesión)	mejor cuando n es mayor
ordenar por fusión	O (iniciar sesión)	O (iniciar sesión)	estabilizar	O(1)	mejor cuando n es mayor
ordenar en montón	O (iniciar sesión)	O (iniciar sesión)	inestable	O(1)	mejor cuando n es mayor

Ordenamiento de burbuja

1. Introducción

Bubble Sort es un algoritmo de clasificación relativamente simple en el campo de la informática.
Visita repetidamente la columna de elementos a ordenar, compara dos elementos adyacentes a su vez y los intercambia si el orden (como de mayor a menor, letra inicial de Z a A) es incorrecto. El trabajo de visita de elementos se repite hasta que no es necesario intercambiar elementos contiguos, es decir, se ha ordenado la columna de elementos.
El nombre de este algoritmo proviene del hecho de que los elementos más pequeños "flotarán" lentamente hacia la parte superior de la secuencia (en orden ascendente o descendente) a través del intercambio, al igual que las burbujas de dióxido de carbono en las bebidas carbonatadas eventualmente flotarán hacia la parte superior. , de ahí el nombre "burbujeante". Ordenar".

2. Análisis del pensamiento

• Compare dos elementos adyacentes, si el primero es mayor que el segundo, cambie las posiciones
• Realice esta operación en cada elemento posterior hasta que el último termine el primer ciclo, por lo que el último elemento debe serelemento más grande, por lo que no es necesario comparar el último elemento en comparaciones de bucle posteriores
• Repita los pasos anteriores para excluirel último elemento del bucle anterior,entoncesbucle interiorsera cada vez menos
• hasta que no haya pares de números para comparar
• lazo exteriorEl número de veces es el número de elementos de la matriz - 1 , y == el número de comparaciones de bucles internos se hace cada vez más pequeño -
• Optimización: si en un determinadoLos elementos no se intercambian en el bucle exterior, prueba que ya es una matriz ordenada, entonces el bucle puede terminar

3. Diagrama

1. El primer ciclo (el amarillo representa la posición de intercambio, el rojo representa la posición final)

2. El segundo ciclo

3. El tercer ciclo

4. El cuarto ciclo

bucle final

4. Implementación del código

/**
 * 冒泡排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Bubbling {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,9,-1,7,21};
        // 外层循环次数为数组的长度-1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            // 内层循环次数，每次都会减少
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                // 交换位置
                if (arr[j] > arr[j+1]){
    
    
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }

}

Optimización: si se encuentra que la posición de los elementos de la matriz no ha cambiado después del final de un determinado ciclo externo, entonces el ciclo finaliza y ya es una matriz ordenada

código:

/**
 * 冒泡排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Bubbling {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,9,-1,7,21};
        // 外层循环次数为数组的长度-1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            // 如果内层循环没有交换位置，那么已经是有序数组，结束循环
            boolean flag = true;
            // 内层循环次数，每次都会减少
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                // 交换位置
                if (arr[j] > arr[j+1]){
    
    
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if (flag){
    
    
                break;
            }
        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }

}

clasificación de selección

1. Introducción

La clasificación por selección es un algoritmo de clasificación simple e intuitivo. Su principio de funcionamiento es: seleccione el elemento más pequeño (o más grande) de los elementos de datos que se ordenarán por primera vez, guárdelo en la posición inicial de la secuencia y luego busque el elemento más pequeño (más grande) de los elementos restantes sin ordenar. y colóquelo al final de la secuencia ordenada. Y así sucesivamente, hasta que el número de todos los elementos de datos a ordenar sea cero. La ordenación por selección es un método de ordenación inestable.

2. Análisis del pensamiento

2.1 Intercambiar datos por primera vez

/**
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Deduction {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    8,3,2,1,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 假设min=0开始
        min = 0;
        // 既然我们都假设下标为0的是最小，那么就从他后面开始比较
        for (int i = 1; i < arr.length; i++) {
    
    
            // 如果后面的元素中有小于的元素，记住的他下标
            if (arr[min] > arr[i]){
    
    
                min = i;
            }
        }
        // 交换
        int temp = arr[0];
        arr[0] = arr[min];
        arr[min] = temp;

        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

        // 打印获取到 1 3 2 8 7 4 6 5 

    }
}

2.2 El segundo tiempo comienza desde i+1

/**
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Deduction {
    
    
    public static void main(String[] args) {
    
    
//        int[] arr = {8,3,2,1,7,4,6,5};
        int[] arr = {
    
    1,3,2,8,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 假设min=1开始
        min = 1;
        // 既然我们都假设下标为1的是最小，那么就从他后面开始比较
        for (int i = 2; i < arr.length; i++) {
    
    
            // 如果后面的元素中有小于的元素，记住的他下标
            if (arr[min] > arr[i]){
    
    
                min = i;
            }
        }
        // 交换
        int temp = arr[1];
        arr[1] = arr[min];
        arr[min] = temp;

        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

        // 打印获取到 1 2 3 8 7 4 6 5 

    }
}

etcétera

2.3 Resumen

• empiezo desde 0, suponiendomin representa el índice del valor mínimo, suponiendo inicialmentemin = yo, EntoncesEncuentre el subíndice del elemento más pequeño en la siguiente matriz, let min = minIndex, intercambiar posiciones,Tenga en cuenta que al buscar el subíndice de índice mínimo, las posiciones de otros elementos no se pueden mover
• Entonces la matriz se mueve hacia atrás, porque el primer número ya es el número más pequeño, no hay necesidad de compararlo, comenzando desde i+1
• Repita los pasos anteriores hasta que finalice la clasificación.
• Se requiere un recorrido total de la longitud de la matriz: 1 vez.

3. Diagrama

4. Implementación del código

/**
 * 选择排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Choice {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    8,3,2,1,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 外层循环次数为数组长度 - 1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            min = i;
            // 内层循环每次都是从i+1开始
            for (int j = i+1; j < arr.length; j++) {
    
    
                // 找出最小数的下标
                if (arr[min] > arr[j]){
    
    
                    min = j;
                }
            }
            // 如果不是同一个数，那么就交换位置
            if (min != i){
    
    
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }
}

tipo de inserción

1. Introducción

La clasificación por inserción también se denomina generalmente clasificación por inserción directa. Es un algoritmo eficiente para ordenar un pequeño número de elementos. La clasificación por inserción es el método de clasificación más simple, su idea básica es insertar un registro enen lista ordenada ordenada, para crear una nueva lista ordenada con el número de registros incrementado en 1. En el proceso de implementación, se utiliza un bucle de doble capa. El bucle exterior busca todos los elementos excepto el primer elemento, y el bucle interior busca la posición que se insertará en la lista ordenada delante del elemento actual y lo mueve .

2. Análisis del pensamiento

• porque la matriz originalprimer elementocomoel primer elemento de una lista ordenada, entonces comience directamente desde el elemento con índice 1, cuando 1 se inserta como elemento para comparar con el último elemento en la lista ordenada
• siinsertar elemento menor que, luego en la lista ordenadaEl último elemento se desplazará un bit hacia atrás., hasta que se encuentre una posición en la lista ordenada donde el elemento no sea mayor que el elemento insertado, oíndice menor que 0, termina la comparación
• Luego asigne el elemento insertado.

3. Diagrama

Tenga en cuenta que la matriz roja aquí ya representa un elemento de lista ordenado

3.1 Primera ronda

3.2 Segunda ronda

3.3 La tercera ronda

3.4 Cuarta ronda

4. Implementación del código

/**
 * 插入排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/9
 */
public class InsertSorted {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3, 1, 6, 10, 2};

        for (int i = 1; i < arr.length; i++) {
    
    
            // 保留即将插入元素的值
            int insertValue = arr[i];
            // 当前索引
            int index = i;
            // 1.如果索引大于0，说明还没遍历完
            // 2.如果插入的值小于有序列表中的值，那么久有序列表中大于插入元素的元素，就要后移
            while (index > 0 && insertValue < arr[index-1]){
    
    
                arr[index] = arr[index-1];
                index --;
            }
            // 直到找到插入元素不大于有序列表中元素的位置
            arr[index] = insertValue;

        }
		// 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

    }
}

---

clasificación de colinas

1. Introducción

Shell's Sort es un tipo de ordenación por inserción, también conocida como "Ordenación incremental decreciente", que es una versión más eficiente y mejorada del algoritmo de ordenación por inserción directa. Hill sort es un algoritmo de clasificación inestable.
La clasificación por colinas consiste en agrupar los registros por un cierto incremento del subíndice y utilizar el algoritmo de clasificación por inserción directa para clasificar cada grupo; a medida que el incremento disminuye gradualmente, cada grupo contiene más y más palabras clave. Cuando el incremento se reduce a 1, el El algoritmo termina cuando todos los datos se acaban de dividir en un grupo.

2. Análisis del pensamiento

• Seleccione una secuencia incremental t1 (generalmente longitud de matriz/2), t2 (generalmente longitud de grupo/2), ..., tk, donde ti > tj, tk = 1;
• De acuerdo con el número de secuencia incremental k, ordene la secuencia k veces;
• Para cada clasificación, de acuerdo con el correspondiente incremento ti, la columna a clasificar se divide en varias subsecuencias de longitud m, y la clasificación por inserción directa se realiza en cada sublista respectivamente. Solo cuando el factor de incremento es 1, la secuencia completa se trata como una tabla y la longitud de la tabla es la longitud de la secuencia completa.

3. Diagrama

3.1 Primera ronda

El incremento es 3, y la comparación comienza directamente desde arr[3], y se encuentra que arr[3] > arr[0], no hay necesidad de cambiar la posición, y arr[4] < arr[1] necesita cambiar la posición, luego

continuar Comparar

Hasta arr[6]<arr[3], intercambie posiciones

y luego encontramos que arr[3] puede compararse con arr[0] porque index-gap >= 0 puede continuar comparándose

3.2 Segunda ronda

Comience a comparar desde arr[1] y compare hacia atrás uno por uno hasta que arr[6] < arr[5]

Después de intercambiar posiciones, compare arr[5] con arr[4] e intercambie posiciones

Finalizar

4. Implementación del código

/**
 * 希尔排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/9
 */
public class ShellInsert {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    23,34,21,31,18,98,10};
        // 增量
        int gap = arr.length/2;
        // 只要增量大于等于1就继续分组
        while (gap >= 1){
    
    

            // 从索引=增量开始，依次往后
            for (int i = gap; i < arr.length; i++) {
    
    
                // 定义一个变量，防止下面代码影响原 i 的值
                int j = i;
                // 只有 arr[j] < arr[j-gap] 交换位置 ，而且可能一次不一定能比较完，需要多次比较 j-gap >= 0
                while (j-gap >= 0 && arr[j] < arr[j-gap]){
    
    
                    // 交换
                    int temp = arr[j];
                    arr[j] = arr[j-gap];
                    arr[j-gap] = temp;
                    // 假设 j = 6 时，可以多次执行
                    j -= gap;
                }
            }

            // 控制增量
            gap /= 2;

        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }

    }
}