Ordenar por algoritmo-burbuja (implementado por código PHP)

Tres minutos para comprender a fondo la clasificación de burbujas

1. Principio: compare dos elementos adyacentes e intercambie el elemento con el valor más grande a la derecha

2. Idea: Compare dos números adyacentes uno por uno, coloque el número más pequeño al frente y el número más grande al final.

(1) La primera comparación: primero compare el primer y el segundo número, colocando el número decimal al frente y el número grande al final.

(2) Compare el segundo y tercer número, coloque el número decimal al frente y el número grande al final.

...

(3) Continúe así, sepa los dos números que se comparan con el anterior, coloque el número decimal en el frente y el número grande en la parte posterior, repita los pasos hasta completar todos los tipos

(4) Una vez completada la comparación anterior, el último número debe ser el número más grande de la matriz, por lo que cuando se realiza la segunda comparación, el último número no se incluye en la comparación.

(5) Una vez completada la segunda ronda de comparación, el penúltimo número también debe ser el penúltimo número de la matriz, por lo que en la tercera ronda de comparación, los dos últimos números no se incluyen en la comparación.

(6) Por analogía, el número de comparaciones en cada paso disminuye secuencialmente

3. Ejemplo:
(1) Para ordenar la matriz: [10,1,35,61,89,36,55]

(2) La primera clasificación:

El primer tipo: 10 y 1, 10 es mayor que 1, posiciones de intercambio [1,10,35,61,89,36,55]

Clasificación por segunda vez: compare 10 y 35, 10 es menor que 35 y no intercambie posiciones [1,10,35,61,89,36,55]

La tercera ronda de clasificación: compare 35 y 61, 35 es menos que 61, no intercambie posiciones [1,10,35,61,89,36,55]

La cuarta ronda de clasificación: compare 61 y 89, 61 es menor que 89, no intercambie posiciones [1,10,35,61,89,36,55]

Clasificación de quinto paso: comparar 89 y 36, 89 es mayor que 36, intercambiar posiciones [1,10,35,61,36,89,55]

La sexta secuencia de tiempo: comparar 89 y 55, 89 es mayor que 55, intercambiar posiciones [1,10,35,61,36,55,89]

Se hicieron un total de seis comparaciones en la primera pasada, y el resultado de la clasificación fue: [1,10,35,61,36,55,89]
　　　　　　
(3) La segunda pasada se clasificó:

La primera clasificación: se comparan 1 y 10, 1 es menor que 10 y las posiciones 1,10,35,61,36,55,89 no se intercambian

El segundo tipo: comparación de 10 y 35, 10 es menor que 35, no intercambie posiciones 1,10,35,61,36,55,89

El tercer orden: comparación 35 y 61, 35 es menor que 61, no intercambie posiciones 1,10,35,61,36,55,89

Cuarto orden: compare 61 y 36, 61 es mayor que 36, intercambie posiciones 1,10,35,36,61,55,89

Quinto orden: compare 61 y 55, 61 es mayor que 55, intercambie posiciones 1,10,35,36,55,61,89

Se hicieron un total de 5 comparaciones en la segunda pasada, y los resultados ordenados: 1,10,35,36,55,61,89

(4) La tercera secuencia de tiempo:

1 se compara con 10, 1 es menor que 10, no hay intercambio de posiciones 1,10,35,36,55,61,89

El segundo tipo: comparación de 10 y 35, 10 es menor que 35, no intercambie posiciones 1,10,35,36,55,61,89

El tercer tipo: comparación 35 y 36, 35 es menor que 36, no intercambie posiciones 1,10,35,36,55,61,89

Cuarto orden: compare 36 y 61, 36 es menor que 61, y no intercambie posiciones 1,10,35,36,55,61,89

En la tercera ronda, se hicieron un total de 4 comparaciones y los resultados de la clasificación: 1,10,35,36,55,61,89

Hasta ahora, la posición ya está en orden.
4. Análisis de algoritmos:

(1) Se puede ver que: N números necesitan ser ordenados, un total de N-1 pasadas son ordenadas y la cantidad de ordenaciones para cada i pasada es (Ni) veces , por lo que se pueden usar declaraciones de doble ciclo, la capa externa controla cuántas veces es el bucle, la capa interna Controla el número de ciclos por pasada

(2) La ventaja de la clasificación de burbujas: cada vez que se realiza la clasificación, habrá menos comparación, porque cada vez que se realiza la clasificación, se encontrará un valor mayor. Como en el ejemplo anterior: después de la primera pasada, el último número debe ser el número más grande. Cuando se ordena la segunda pasada, solo necesita comparar otros números excepto el último número, y también puede encontrar el número más grande. El número de se clasifica detrás del número que participó en la segunda ronda de comparación. En la tercera ronda de comparación, solo necesita comparar los otros números excepto los dos últimos números, y así sucesivamente ... Es decir, no hay comparación, cada vez Comparar menos una vez por viaje reduce la cantidad de algoritmos hasta cierto punto.

(3) Complejidad del tiempo

1. Si nuestros datos están en orden positivo, solo necesitamos hacer un viaje para completar la clasificación. Los tiempos de comparación requeridos C y los tiempos de movimiento registrados M alcanzan el mínimo, a saber: Cmin = n-1; Mmin = 0; Por lo tanto, la mejor complejidad de tiempo para la clasificación de burbujas es O (n).

2. Si, lamentablemente, nuestros datos están en orden inverso, debemos ordenarlos por n-1 veces. Cada secuencia requiere ni comparaciones (1≤i≤n-1), y cada comparación debe mover el registro tres veces para alcanzar la posición del registro de intercambio. En este caso, el número de comparaciones y movimientos alcanzó el máximo:
　　　　
En resumen: la complejidad de tiempo promedio total de la clasificación de burbujas es: O (n2), y la complejidad de tiempo es independiente del estado de los datos.

Implementación de código PHP

1. Implementación de código básico

    /**
     * 冒泡排序
     * @param $arr
     */
    public function bubbleSort($arr)
    {
    
    
        $length = count($arr);
        for ($i=1;$i<$length;$i++) {
    
     //需要执行 length-1 趟排序
            for ($j=0;$j<$length-$i;$j++) {
    
     //每趟需要执行 length-i 次比较
                //两两比较相邻元素
                if($arr[$j] > $arr[$j+1]){
    
    
                    $this->swap($arr, $j,$j+1);
                }
            }
        }
        return $arr;
    }

    /**
     * 数组元素交换位置
     * @param array $arr
     * @param $a
     * @param $b
     */
    function swap(array &$arr, $a, $b)
    {
    
    
        $temp = $arr[$a];
        $arr[$a] = $arr[$b];
        $arr[$b] = $temp;
    }

2. Optimización de clasificación

Puede introducir una bandera para determinar si necesita ingresar al siguiente ciclo. Cuando no hay intercambio de datos, significa que los datos ya están en orden y no necesita ingresar al siguiente ciclo.

    /**
     * 冒泡排序
     * @param $arr
     */
    public function bubbleSort($arr)
    {
    
    
        $length = count($arr);
        $flag = true; //是否需要进行下一趟排序标志
        if ($flag) {
    
    
            for ($i=1;$i<$length;$i++) {
    
     //需要执行 length-1 趟排序
                $flag = false; //每次进入一趟循环默认下一次不再循环
                for ($j=0;$j<$length-$i;$j++) {
    
     //每趟需要执行 length-i 次比较
                    //两两比较相邻记录
                    if($arr[$j] > $arr[$j+1]){
    
    
                        $this->swap($arr, $j,$j+1);
                        $flag = true;  //当有数据发生交换，说明还需要下一趟排序
                    }
                }
            }
        }
        return $arr;
    }

    /**
     * 数组元素交换位置
     * @param array $arr
     * @param $a
     * @param $b
     */
    function swap(array &$arr, $a, $b)
    {
    
    
        $temp = $arr[$a];
        $arr[$a] = $arr[$b];
        $arr[$b] = $temp;
    }

Dirección de referencia para este artículo

1. https://www.jb51.net/article/138558.htm
2. https://www.cnblogs.com/bigdata-stone/p/10464243.html