[Estructura de datos y algoritmo] Clasificación de burbujas

Tipo de burbuja:

Complejidad del tiempo: O (n ^ 2)
Complejidad del espacio: O (1)

Prueba:
Ordenar por números aleatorios de 10k: puede ver que la velocidad aumenta o disminuye.

冒泡排序      : 	0.411331 s
冒泡排序优化1  : 	0.428745 s
冒泡排序优化2  : 	0.416507 s

10k cerca del orden de los números ordenados: puede ver que la versión optimizada es más rápida.

冒泡排序       :       0.115256 s
冒泡排序优化1   :       0.000819 s
冒泡排序优化2   :       0.000736 s

Idea básica:
comparar dos por dos, el elemento de posición actual se compara con el siguiente elemento, el grande se coloca detrás y el pequeño se coloca delante.
Después de completar una ronda de comparación, el último elemento es el elemento más grande.

void sort1(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

Optimización 1: después de
ordenar, la matriz ya puede estar en orden.
En este momento, realizamos otro ciclo y no se produce ningún intercambio, lo que indica que ya está en orden.

void sort2(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        bool is_order = true;  // 假设已经有序
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                is_order = false;  // 发生元素交换，可能还是无序
                swap(arr[j], arr[j + 1]);
            }
        }
        if (is_order) {  // 如果有序就退出
            break;
        }
    }
}

Optimización 2:
determinación del intervalo de clasificación.
Para 3 2 1 0 7 8 9, después de un ciclo, se convierte en 2 1 0 3 7 8 9 y la última posición intercambiada es el intervalo no ordenado.
Simplemente registre la última posición de intercambio de cada ronda.

void sort3(int arr[], int n) {
    int sort_end = n - 1;
    int last_exchange = 0;
    for (int i = 0; i < n - 1; ++i) {
        bool is_order = true;
        for (int j = 0; j < sort_end; ++j) {
            if (arr[j] > arr[j + 1]) {
                is_order = false;
                last_exchange = j;
                swap(arr[j], arr[j + 1]);
            }
        }
        if (is_order) {
            break;
        }
        sort_end = last_exchange;
    }
}

---

EOF