Algoritmo de clasificación de burbujas (BubbleSort)

Algoritmo de clasificación de burbujas (BubbleSort)

La clasificación de burbujas recibe su nombre de "los elementos adyacentes se intercambian constantemente durante el proceso de clasificación, y algunos elementos se reemplazan lentamente hasta el final, lo que parece como si los elementos estuvieran burbujeando". Es el algoritmo de clasificación más simple. Por lo general, se usa para explicar la introducción algoritmo de programación informática.

Definición

La implementación del algoritmo se divide en los siguientes pasos:

1. Compare dos elementos adyacentes desde el principio cada vez
2. Si el último elemento es más pequeño que el anterior, significa que el orden es incorrecto, entonces cámbielos
3. Una vez completado el ciclo, escanee desde el principio nuevamente hasta que no haya intercambio de elementos en un escaneo determinado, y repita los dos procesos anteriores continuamente hasta que todo esté en orden.

Por ejemplo, hay una matriz que debe ordenarse: 5,8,6,3,9,2,1,7 (ordenar de pequeña a grande):

La primera ronda de clasificación:

1. Primero intercambie 5 y 8, y encuentre que 5 es menor que 8, así que omítalo.

Comparando 2, 8 y 6, encuentre que 8 es mayor que 6, intercambie posiciones.

3, 8 se compara con 3, 8 es mayor que 3 y las posiciones se intercambian.

4, 8 y 9, 8 es menor que 9, omita

Compare 5, 9 y 2, 9 es mayor que 2, intercambie

Compare 6, 9 y 1, encuentre que 9 es mayor que 1, intercambie posiciones.

7. Finalmente, dejemos que el 9 y el 7 intercambien posiciones

De esta manera, el elemento 9 como el elemento más grande de la secuencia ya está ordenado.

Puede ver que el número más grande se ha ordenado hasta el final y no es necesario que recorra los elementos ordenados la próxima vez.

Implementación

// 普通冒泡算法
    public static void bubbleSort(int[] arr){
    
    
        int i,j,temp,len = arr.length;
        for (i = 0; i < len -1; i++) {
    
    
            for (j = 0; j < len - 1- i; j++) {
    
    
                if(arr[j] > arr[j+1]){
    
    
                     temp = arr[j+1];
                     arr[j+1] = arr[j];
                     arr[j] = temp;
                }
            }
        }
    }

    // 改进的冒泡算法，利用flag做标记。如果在本轮排序中，元素有交换，则说明数列无序，如果没有交换，则说明数列已然有序，直接返回。
    public static void bubbleSort1(int[] arr){
    
    
        boolean flag = true;
        int temp,j = 0; //j的作用是不再遍历已经排序好的数
        while(flag){
    
    
            flag = false;
            for (int i = 0; i< arr.length -1-j;i++){
    
    
                if(arr[i] > arr[i+1]){
    
    
                    temp = arr[i+1];
                    arr[i+1] = arr[i];
                    arr[i] = temp;
                    flag = true;
                }
            }
            j++;
        }
    }

prueba:

public static void main(String[] args) {
    
    
        int[] arr = new int[]{
    
    1,2,5,6,4,2,3,1,7};
        bubbleSort1(arr);
        System.out.println(Arrays.toString(arr));
    }

resultado:

[1, 1, 2, 2, 3, 4, 5, 6, 7]

Fuente de la imagen: lu_1079776757 (perdóname por no hacer fotos)