I. Introducción
La clasificación de burbujas es una clasificación de intercambio.
¿Qué es un tipo de intercambio?
La respuesta es: compare las palabras clave que se ordenarán en pares e intercambie los pares que no cumplan con los requisitos del pedido hasta que toda la tabla cumpla con los requisitos del pedido.
2. Pensamiento algorítmico
Recorre repetidamente la secuencia que se va a ordenar, compara dos elementos a la vez y los intercambia si están en el orden incorrecto. El trabajo de visitar la secuencia se repite hasta que no se necesitan más intercambios, es decir, la secuencia ha sido ordenada.
El nombre de este algoritmo proviene del hecho de que los elementos más pequeños "flotarán" lentamente hacia la parte superior de la secuencia a través del intercambio, de ahí el nombre de clasificación de burbuja.
Diagrama esquemático del efecto dinámico:
Supongamos que hay una secuencia desordenada de tamaño N. Tomemos como ejemplo la clasificación de burbuja ascendente. La clasificación de burbuja consiste en comparar elementos adyacentes por pares en cada proceso de clasificación, colocando números pequeños en el frente y números grandes en la parte posterior.
1. Código
C++:
#include <iostream>
#include <vector>
using namespace std;
vector<int> bubbleSort(vector<int> list){
vector<int> result;
if (list.empty()){
return result;
}
result = list;
int temp;
// 要遍历的次数
for (int i = 0; i < result.size() - 1; ++i){
cout << "第" << i + 1 << "趟排序:" << endl;;
// 从后向前依次的比较相邻两个数的大小
for (int j = 0; j < result.size() - 1; j++){
// 如果后面的元素小，则交换它们的位置
if (result[j + 1] < result[j]){
temp = result[j + 1];
result[j + 1] = result[j];
result[j] = temp;
}
cout << "排序中:";
for (int s = 0; s < result.size(); s++){
cout << result[s] << " ";
}
cout << endl;
}
cout << "排序结果:";
for (int s = 0; s < result.size(); s++){
cout << result[s] << " ";
}
cout << endl;
}
return result;
}
void main(){
int arr[] = { 6, 4, 8, 1, 2, 3, 9 };
vector<int> test(arr, arr + sizeof(arr) / sizeof(arr[0]));
cout << "排序前" << endl;
for (int i = 0; i < test.size(); i++){
cout << test[i] << " ";
}
cout << endl;
vector<int> result;
result = bubbleSort(test);
cout << "排序后" << endl;
for (int i = 0; i < result.size(); i++){
cout << result[i] << " ";
}
cout << endl;
system("pause");
}resultado de la operación:
Pitón:
# -*- coding:utf-8 -*-
def bubbleSort(input_list):
'''
函数说明:冒泡排序（升序）
Author:
www.cuijiahua.com
Parameters:
input_list - 待排序列表
Returns:
sorted_list - 升序排序好的列表
'''
if len(input_list) == 0:
return []
sorted_list = input_list
for i in range(len(sorted_list) - 1):
print('第%d趟排序:' % (i + 1))
for j in range(len(sorted_list) - 1):
if sorted_list[j + 1] < sorted_list[j]:
sorted_list[j], sorted_list[j + 1] = sorted_list[j + 1], sorted_list[j]
print(sorted_list)
return sorted_list
if __name__ == '__main__':
input_list = [50, 123, 543, 187, 49, 30, 0, 2, 11, 100]
print('排序前:', input_list)
sorted_list = bubbleSort(input_list)
print('排序后:', sorted_list)El efecto de la operación es el mismo que el anterior.
3. Análisis de algoritmos
1. El rendimiento del algoritmo de clasificación de burbujas
2. Complejidad del tiempo
Si el estado inicial del archivo es en orden positivo , la clasificación se puede completar en un escaneo. El número requerido de comparaciones de palabras clave C y el número de movimientos de registros M alcanzan el valor mínimo: Cmin = N - 1, Mmin = 0. Por lo tanto, la mejor complejidad temporal del tipo burbuja es O(N).
Sin embargo, el código anterior no puede completar la clasificación en un solo escaneo, realizará un escaneo completo. Por lo tanto, un método mejorado es que cuando se encuentra que ya está en orden positivo durante el burbujeo, no hay necesidad de continuar con la comparación. El método de mejora se introducirá en un momento.
Si el archivo original está en orden inverso , se requiere clasificación N-1. Cada clasificación requiere N - i comparaciones de palabras clave (1 ≤ i ≤ N - 1), y cada comparación debe mover el registro tres veces para intercambiar la posición del registro. En este caso, tanto las comparaciones como los movimientos están al máximo:
Cmáx = N(N-1)/2 = O(N^2)
Mmáx = 3N (N-1) / 2 = O (N^2)
La peor complejidad temporal del tipo de burbuja es O(N^2).
Por lo tanto, la complejidad de tiempo promedio del tipo de burbuja es O (N ^ 2).
En resumen, en realidad es una oración: cuanto más cerca estén los datos del orden positivo, mejor será el rendimiento de la ordenación de burbujas.
3. Estabilidad del algoritmo
Suponiendo que hay varios registros con la misma palabra clave en la secuencia de registros que se ordenarán, si se ordenan, el orden relativo de estos registros permanece sin cambios, es decir, en la secuencia original, r[i]=r[j], y r [i] está antes de r[j], y en la secuencia ordenada, r[i] todavía está antes de r[j], se dice que el algoritmo de clasificación es estable; de lo contrario, se dice que es inestable.
La ordenación de burbuja es para mover elementos pequeños hacia adelante o elementos grandes hacia atrás. es una comparación de dos elementos adyacentes, y el intercambio también ocurre entre estos dos elementos. Entonces, el orden de los mismos elementos no cambia, por lo que la clasificación de burbujas es un algoritmo de clasificación estable .
4. Optimización
Un método de mejora común para la clasificación de burbujas es agregar un intercambio de variables simbólicas , que se utiliza para marcar si hay intercambio de datos en un determinado proceso de clasificación.
Si no hay intercambio de datos durante una determinada clasificación, significa que todos los datos están en orden y la clasificación se puede finalizar de inmediato para evitar un proceso de comparación innecesario.
1. Código
C++:
#include <iostream>
#include <vector>
using namespace std;
vector<int> bubbleSort(vector<int> list){
vector<int> result;
if (list.empty()){
return result;
}
result = list;
int temp;
// 要遍历的次数
for (int i = 0; i < result.size() - 1; ++i){
cout << "第" << i + 1 << "趟排序:" << endl;;
//交换标志位
bool bChanged = false;
// 从后向前依次的比较相邻两个数的大小
for (int j = 0; j < result.size() - 1; j++){
// 如果后面的元素小，则交换它们的位置
if (result[j + 1] < result[j]){
temp = result[j + 1];
result[j + 1] = result[j];
result[j] = temp;
bChanged = true;
}
cout << "排序中:";
for (int s = 0; s < result.size(); s++){
cout << result[s] << " ";
}
cout << endl;
}
// 如果标志为false，说明本轮遍历没有交换，已经是有序数列，可以结束排序
if (false == bChanged){
break;
}
cout << "排序结果:";
for (int s = 0; s < result.size(); s++){
cout << result[s] << " ";
}
cout << endl;
}
return result;
}
void main(){
int arr[] = { 6, 4, 8, 1, 2, 3, 9 };
vector<int> test(arr, arr + sizeof(arr) / sizeof(arr[0]));
cout << "排序前" << endl;
for (int i = 0; i < test.size(); i++){
cout << test[i] << " ";
}
cout << endl;
vector<int> result;
result = bubbleSort(test);
cout << "排序后" << endl;
for (int i = 0; i < result.size(); i++){
cout << result[i] << " ";
}
cout << endl;
system("pause");
}resultado de la operación:
Pitón:
# -*- coding:utf-8 -*-
def bubbleSort(input_list):
'''
函数说明:冒泡排序（升序）
Author:
www.cuijiahua.com
Parameters:
input_list - 待排序列表
Returns:
sorted_list - 升序排序好的列表
'''
if len(input_list) == 0:
return []
sorted_list = input_list
for i in range(len(sorted_list) - 1):
bChanged = False
print('第%d趟排序:' % (i + 1))
for j in range(len(sorted_list) - i - 1):
if sorted_list[j + 1] < sorted_list[j]:
sorted_list[j], sorted_list[j + 1] = sorted_list[j + 1], sorted_list[j]
bChanged = True
print(sorted_list)
if not bChanged:
break
return sorted_list
if __name__ == '__main__':
input_list = [50, 123, 543, 187, 49, 30, 0, 2, 11, 100]
print('排序前:', input_list)
sorted_list = bubbleSort(input_list)
print('排序后:', sorted_list)El efecto de la operación es el mismo que el anterior.
Finalmente, enviarle dos notas de cepillado:
- Notas de cepillado de Leetcode de Google y Ali
- Me tomó 3 meses, y resumí las notas de cepillado de la oferta de 6w palabra + punta de espada.
No es fácil ser original. Si ayuda o inspira un poco, ¡espero darle a Jack un tres clic!
¡Ojalá todo el que lo esté haciendo sea un cosechador de ofe, y los tres superdobles consecutivos!