Intercambio de clasificación-clasificación de burbujas y clasificación rápida

La idea básica de la clasificación de intercambio es comparar los códigos clave de los registros de secuencia que se ordenarán par por par. Si los registros se invierten, se intercambian hasta que no haya un par inverso. La clasificación de burbujas y la clasificación rápida son algoritmos típicos de clasificación de intercambio.

Tipo de burbuja

La clasificación por burbujas y la clasificación por inserción directa son quizás los métodos de clasificación más utilizados en nuestras vidas. La clasificación por burbujas consta de dos capas de bucles anidados: el bucle externo determina una posición a la vez, y el bucle interno es relativo a la capa externa, desde la dirección opuesta. Los elementos adyacentes se comparan uno por uno hasta la posición actual de la capa externa, y luego se obtiene el valor correspondiente.

El diagrama de presentación dinámica es el siguiente: el

código se implementa de la siguiente manera (en la dirección opuesta a la clasificación del diagrama de presentación dinámica):

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args){
		// 待排序列
        int[] arrOriginal = new int[]{5, 9, 7, 4, 22, 2, 65, 1, 45};
        System.out.println("before sort, the array is: ");
        System.out.println(Arrays.toString(arrOriginal));

		// 临时变量，内层循环中交换元素时应用
        int temp = 0;
        boolean noSwap;
        // 外层：从某一端开始，确定要排序的某个位置
        for (int i = 0; i < arrOriginal.length; i++) {
        	noSwap = true;
        	// 内层：从另一端开始，确定外层位置对应的值
            for (int j = arrOriginal.length - 1 ; j > i; j--) {
                if(arrOriginal[j] < arrOriginal[j-1]){
                    temp = arrOriginal[j];
                    arrOriginal[j] = arrOriginal[j-1];
                    arrOriginal[j-1] = temp;
                    noSwap = false;
                }
            }
            if(noSwap) {
                break;
            }
        }
        System.out.println("\nend sort, the array is: ");
        System.out.println(Arrays.toString(arrOriginal));
    }
}

Al igual que con la clasificación por inserción directa, la complejidad de tiempo óptima es O (n), y el promedio y el peor de los casos son O (n ² ).

Ordenación rápida

La clasificación rápida, inventada en 1962, encarna la idea de dividir y conquistar: primero, seleccione el valor del eje; luego, compare los elementos de secuencia que se ordenarán con el valor del eje respectivamente, divídalo en ambos lados del valor del eje y fije la posición del elemento del valor del eje; finalmente, apunte a Los lados izquierdo y derecho invocan recursivamente el algoritmo de ordenación rápida hasta que el número de elementos de secuencia que se ordenarán sea menor que 2.

El diagrama de demostración dinámica es el siguiente: el

código se implementa de la siguiente manera:

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args){
        int[] arrOriginal = new int[]{5, 9, 7, 4, 22, 2, 65, 1, 45};
        System.out.println("before sort, the arr is: ");
        System.out.println(Arrays.toString(arrOriginal));

        quickSortProcess(arrOriginal, 0, arrOriginal.length-1);

        System.out.println("end sort, the arr is: ");
        System.out.println(Arrays.toString(arrOriginal));
    }

    public static void quickSortProcess(int[] arr, int startIdx, int endIdx) {
        if (startIdx >= endIdx){
            return;
        }
        // 1. 选择轴值
        int flagIndex = (startIdx + endIdx) / 2;
        int flagValue = arr[flagIndex];

        
        // 2. 将轴值与末尾元素交换，确定一个可交换的元素
        switchVal(arr, flagIndex, endIdx);
        // 设定正向与反向游标指针
        int forwardIdx = startIdx;
        int reverseIdx = endIdx;
        // while 正idx < 反idx
        while(forwardIdx < reverseIdx) {
            // 正向从起始元素开始，遇到比轴值大的元素时，与反向指针元素交换位置，正向指针暂停，break；否则正向+1
            while(forwardIdx < reverseIdx && arr[forwardIdx] < flagValue){
                forwardIdx++;
            }
            switchVal(arr, forwardIdx, reverseIdx);

            // 反向从结束元素开始，遇。。。。小。。。。，。正。。。。。。。。。，反向指针暂停，break；。。反向-1
            while(forwardIdx < reverseIdx && arr[reverseIdx] > flagValue){
                reverseIdx--;
            }
            switchVal(arr, forwardIdx, reverseIdx);
        }

        // 3. 二分，递归调用（注释代码为错误示范，出现堆栈溢出的异常）
        // quickSortProcess(arr, startIdx, endIdx/2);
        // quickSortProcess(arr, (endIdx/2 + 1), endIdx);
        quickSortProcess(arr, startIdx, forwardIdx);
        quickSortProcess(arr, forwardIdx+1, endIdx);
    }

    public static void switchVal(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

La complejidad del tiempo de clasificación rápida es: el peor de los casos es O (n ² ), y el mejor y el caso promedio es O (nlogn)

Resumen

Tanto el burbujeo como la clasificación rápida se basan en la idea de la clasificación de intercambio y proporcionan diferentes implementaciones, entre ellas, el burbujeo se basa en la idea de clasificación en nuestro mundo decimal, elegir el más grande o el más pequeño cada vez y luego buscar el siguiente más grande o el más grande de los elementos de datos restantes. Es el segundo más pequeño, por lo que es un tipo estable, pero esta idea intuitiva tiene una complejidad temporal del nivel cuadrado y no es adecuada para grandes volúmenes de datos.
La clasificación rápida utiliza la idea de dividir y conquistar. Mediante la división de arriba hacia abajo, el problema de clasificación se reduce en tamaño. Al completar la clasificación a pequeña escala, finalmente se logra el efecto de clasificación general y la ejecución es más eficiente.

Referencia:
"Estructura de datos y algoritmo"
Bubble sort-wikiwand
Quicksort-wikiwand

Descarga del código de muestra de la serie: bienvenido a seguir mi github