Tabla de contenido

Prefacio

Este artículo explica los algoritmos de clasificación de burbujas, clasificación de selección y clasificación de inserción (explicación mental + animación + código (lenguaje java)), que son tres clases simples.

1. Clasificación de burbujas

1.1 Idea de clasificación de burbujas

Compare dos números adyacentes a su vez, colocando el número más pequeño en el frente y el número más grande en la parte de atrás.

1.2 Diagrama de clasificación de burbujas

1.3 Implementación del código de clasificación de burbujas

//冒泡排序，可直接运行
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {9,6,14,2,55,12,34,7};
        sortByBubble(arr);
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

    private static void sortByBubble(int[] arr) {
        if (arr==null || arr.length < 2){
            return;
        }
        boolean flag;
        for (int i = 0;i < arr.length;i++){
            flag = false;
            //此处-1是为了防止数组下标溢出 a[j+1]
            //若不减一，此处的例子上a[j+1]则会变成a[a.length]
            for (int j = 0;j < arr.length - i - 1;j++){
                int temp;
                if (arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
            if (!flag){
                break;
            }
        }
    }

}

Clasificación de primer paso:

　　　　　　El primer tipo: 9 y 6, 9 es mayor que 6, posiciones de intercambio [ 9,6 , 14,2,55,12,34,7]
　　　　　　La segunda ronda de clasificación: 9 y 14, 9 es menor que 14, no intercambie posiciones [6, 9,14 , 2,55,12,34,7]
　　　　　　Tiempos de tercer orden: 14 y el segundo comparador 14 es mayor que 2, cambiar de posición [6,9 , 2,14 , 55,12,34,7]
　　　　　　La cuarta ronda de clasificación: compare 14 y 55, 14 es menor que 55 y no intercambie posiciones [6,9,2, 14,55 , 12,34,7]
　　　　　 La quinta ronda de clasificación: comparar 55 y 12, 55 es mayor que 12, intercambiar posiciones [6,9,2,14, 12,55 , 34,7 ]
　　　　　　La sexta secuencia de tiempo: comparar 55 y 34, 55 es mayor que 34, intercambiar posiciones [6,9,2,14,12, 34,55 , 7]
Orden de séptima ronda: comparar 55 y 7, 55 es mayor que 7, intercambiar posiciones [6,9,2,14,12,34, 7,55 ]
　　　　　　Se hicieron un total de siete comparaciones en la primera pasada, y los resultados ordenados: [6,9,2,14,12,34,7,55]

Clasificación por segunda vez:

　　　　　　La primera clasificación: 6 y 9, 6 es menor que 9, sin intercambiar posiciones [ 6,9, 2,14,12,34,7,55]
　　　　　　Segunda ronda de clasificación: 9 y 2, 9 es mayor que 2, intercambiar posiciones [6, 2,9 , 14,12,34,7,55]
　　　　　　Tiempos de tercer orden: 9 y 14 en comparación con menos de 14 9, no cambia de posición [6,2, 9,14 , 12,34,7,55]
　　　　　　La cuarta ronda de clasificación: 12 y 14, 14 es mayor que 12, intercambiar posiciones [6,2,9, 12,14 , 34,7,55]
　　　　　 Tiempos de quinto orden: 14 y el comparador 34, 14 es menor que 34, sin cambiar la posición [6,2,9,12, 14, 34 , 7,55]
　　　　　　La sexta secuencia de tiempo: comparar 34 y 7, 34 es mayor que 7, intercambiar posiciones [6,2,9,12,14, 7,34 , 55]
　　　　　　Se hicieron un total de seis comparaciones en la segunda pasada, y los resultados ordenados: [6,2,9,12,14,7,34,55]

La tercera secuencia de tiempo:

　　　　　　El primer tipo: 6 y Comparativo 2, 6 es mayor que 2, cambia de posición [ 2,6 , 9,12,14,7,34,55]
　　　　　　La segunda ronda de clasificación: compare 6 y 9, 6 es menor que 9, no intercambie posiciones [2, 6,9 , 12,14,7,34,55]
　　　　　　La tercera ronda de clasificación: comparación de 9 y 12, 9 es menor que 12, no intercambie posiciones [2,6, 9,12 , 14,7,34,55]
　　　　　　La cuarta ronda de clasificación: 12 y 14, 12 es menor que 14, no intercambie posiciones [ 2,6,9 , 12,14 , 7,34,55]
　　　　　 Tiempos de quinto orden: 14 y Comparativo 7, 14 mayor que 7, la posición de cambio [2,6,9,12, 7, 14 , 34,55]
　　　　　　Se hicieron un total de cinco comparaciones en la tercera pasada, y los resultados ordenados: [2,6,9,12,7,14,34,55]

Tipo de cuarto pase:

　　　　　　El primer tipo: 2 y 6, 2 es menor que 6, no intercambie posiciones [ 2,6 , 9,12,7,14,34,55]
　　　　　　Segunda pasada de clasificación: 6 y Comparativo 9, 6 es menor que 9, sin posición de intercambio [2, 6,9 , 12,7,14,34,55]
　　　　　　Tiempos de tercer orden: 9 y 12 en comparación con menos de 12 9, no cambia de posición [2,6, 9,12 , 7,14,34,55]
　　　　　　Tiempos de cuarto orden: 12 y Comparativo 7, 12 mayor que 7, la posición de cambio [2,6,9, 7,12 , 14,34,55]
　　　　　　Se hicieron un total de cuatro comparaciones en la cuarta pasada y los resultados ordenados: [2,6,9,7,12,14,34,55]

La quinta secuencia de tiempo:

　　　　　　La primera clasificación: 2 y 6, 2 es menor que 6, no intercambian posiciones [ 2,6 , 9,7,12,14,34,55]
　　　　　　La segunda ronda de clasificación: 6 y 9, 6 es menor que 9, no intercambie posiciones [2, 6,9 , 7,12,14,34,55]
　　　　　　La tercera secuencia de tiempo: 9 y 7, 9 es mayor que 12, intercambia posiciones [2,6, 7,9 , 12,14,34,55]
　　　　　　Se hicieron un total de tres comparaciones en el quinto paso y los resultados ordenados: [2,6,7,9,12,14,34,55]

La sexta secuencia de tiempo:

　　　　　　El primer tipo: 2 y 6, 2 es menor que 6, no intercambie posiciones [ 2,6 , 7,9,12,14,34,55]
　　　　　　La segunda ronda de clasificación: compare 6 y 7, 6 es menor que 7, no intercambie posiciones [2, 6,7 , 9,12,14,34,55]
　　　　　　En la sexta ronda, se hicieron un total de dos comparaciones y los resultados ordenados: [2,6,7,9,12,14,34,55]

Tipo de séptimo pase:

　　　　　　El primer tipo: 2 y 6, 2 es menor que 6, no intercambie posiciones [ 2,6 , 7,9,12,14,34,55]
　　　　　　En el séptimo paso, se realizó un total de una comparación y los resultados ordenados: [2,6,7,9,12,14,34,55]

1.4 Análisis de complejidad temporal de la clasificación de burbujas

Después de configurar la variable de bandera:

Cuando la secuencia original está organizada en "orden positivo", el número total de comparaciones de clasificación de burbujas es n-1 y el número de movimientos es 0, lo que significa que la complejidad de tiempo de clasificación de burbujas en el mejor de los casos es O (n );

Cuando la secuencia original se ordena en "orden inverso", el número total de comparaciones para la clasificación de burbujas es n (n-1) / 2, y el número de movimientos es 3n (n-1) / 2 veces, por lo que el peor- tiempo de caso para la clasificación de burbujas La complejidad es O (n ^ 2);

Cuando la secuencia original está fuera de orden, la complejidad de tiempo promedio de la clasificación de burbujas es O (n ^ 2).

1.5 Complejidad espacial del tipo de burbuja

El proceso de clasificación de burbujas requiere una variable temporal para el intercambio por pares, y el espacio adicional requerido es 1, por lo que la complejidad del espacio es O (1) .

2. Elija Ordenar

2.1 Elija una idea de clasificación

1. En cada proceso transversal, se asume que el elemento en el primer índice es el valor mínimo y se compara con los valores en otros índices sucesivamente.

Si el valor en el índice actual es mayor que el valor en algún otro índice, se asume que el valor de algún otro índice es el valor mínimo, y finalmente se puede encontrar el índice donde se encuentra el valor mínimo.

2. Cambie el valor en el primer índice y el índice en el mínimo.

2.2 Diagrama de selección y clasificación

2.3 Selección de implementación del código de clasificación

/**
 * 选择排序，可直接运行
 */
public class SelectionSort {

    public static void main(String[] args) {
        int[] arr = {9,6,14,2,55,12,34,7};
        sortBySelect(arr);
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

    private static void sortBySelect(int[] arr) {
        if (arr ==null || arr.length < 2){
            return;
        }
        for (int i = 0; i < arr.length -1; i++) {
            //假定本次遍历，最小值所在的索引是i
            int min = i;
            int temp;
            //需要理解这里的 i+1 和 j < arr.length
            for (int j = i+1; j < arr.length; j++) {
                if (arr[min] > arr[j]){
                    //找到一个比自己小的就把它记下来，
                    //接着再用这个比自己小的和后续的比较
                    min = j;
                }
            }
            //此时arr[min]为最小的，和刚开始假定的最小值arr[i]进行交换
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
}

2.4 Análisis de complejidad temporal del tipo de selección

La clasificación selectiva utiliza un bucle for de doble capa, donde el bucle externo completa el intercambio de datos y el bucle interno completa la comparación de datos, por lo que contamos por separado el número de intercambios y comparaciones de datos:

Tiempos de comparación de datos: (N-1) + (N-2) + (N-3) + ... + 2 + 1 = ((N-1) +1) * (N-1) / 2 = N ^ 2/2-N / 2;

Número de intercambios de datos: N-1

Complejidad de tiempo: N ^ 2/2-N / 2 + (N-1) = N ^ 2/2 + N / 2-1;

De acuerdo con la regla de derivación de Big O, se retiene el término de mayor orden, se elimina el factor constante y la complejidad del tiempo es O (N ^ 2);

2.5 Análisis de complejidad espacial del tipo de selección

Complejidad espacial. En el caso óptimo (ya en orden) la complejidad es: O (0); en el peor caso (todos los elementos deben reordenarse) la complejidad es: O (n) ;; la complejidad temporal promedio Grado: O ( 1)

3. Orden de inserción

3.1 Principio de ordenación por inserción

1. Trate el primer elemento de la primera secuencia a ordenar como una secuencia ordenada, y trate el segundo elemento al último elemento como una secuencia sin ordenar.

2. Escanee la secuencia sin clasificar de principio a fin, inserte cada elemento escaneado en la posición correcta de la secuencia ordenada.

(Si el elemento a insertar es igual a un elemento en la secuencia ordenada, el elemento a insertar se inserta después del elemento igual).

3.2 Diagrama de clasificación por inserción

3.3 Insertar implementación de código de clasificación

/**
 * 插入排序,可直接运行
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {9, 6, 14, 2, 55, 12, 34, 7};
        sortByInsert(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    private static void sortByInsert(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        //从数组下标为 1 的地方和前面的元素进行比较，开始选择合适的地方进行插入
        //因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i++) {
            //把该需要比较的元素先保存一份
            int temp = arr[i];
            //从已经排序的最右边开始进行比较，找到比其小的数
            int j = i;
            while(j>0 && temp < arr[j - 1]){
                //如果比较的元素小的话，将比较的对应元素向后移动
                arr[j] = arr[j - 1];
                j--;
            }
            //如果j==i，那么排好序的元素都比需要比较的元素小，不需要插入
            //如果j!=i，那么说明有比需要比较的元素小的数，并且位置移动了，需要插入
            if (j!=i){
                arr[j] = temp;
            }
        }
    }

}

3.4 Análisis de complejidad temporal del tipo de inserción:

La ordenación por inserción utiliza un bucle for de doble capa, donde el cuerpo del bucle del bucle interno es el código que realmente completa la ordenación. Por lo tanto, analizamos la complejidad temporal de la ordenación por inserción, principalmente analizando el número de ejecuciones del cuerpo del bucle interno.

En el peor de los casos, el elemento de la matriz a ordenar es {55,34,14,12,9,7,6,2}, entonces:

El número de comparaciones es: (N-1) + (N-2) + (N-3) + ... + 2 + 1 = ((N-1) +1) * (N-1) / 2 = N ^ 2/2-N / 2;

El número de intercambios es: (N-1) + (N-2) + (N-3) + ... + 2 + 1 = ((N-1) +1) * (N-1) / 2 = N ^ 2/2-N / 2;

El número total de ejecuciones es: (N ^ 2/2-N / 2) + (N ^ 2/2-N / 2) = N ^ 2-N;

De acuerdo con la regla de derivación de Big O, la complejidad temporal de la clasificación de inserción final es O (N ^ 2) si se conserva el término de mayor orden en la función .

La clasificación por inserción no es adecuada para clasificar aplicaciones con una cantidad relativamente grande de datos. Sin embargo, si la cantidad de datos a ordenar es pequeña, por ejemplo, la magnitud es menor que mil; o si se sabe que los elementos de entrada están ordenados aproximadamente, la ordenación por inserción sigue siendo una buena opción. La ordenación por inserción también se usa ampliamente en bibliotecas de grado industrial. En el algoritmo de ordenación de STL y el algoritmo qsort de stdlib, la ordenación por inserción se utiliza como complemento de la ordenación rápida para clasificar una pequeña cantidad de elementos.

================================================

Además, si cree que el artículo es útil para usted, haga clic en el siguiente botón:
Su apoyo es mi motivación para la perseverancia.