Complejidad del tiempo de clasificación de burbujas
En este artículo, se considera la ascendente de clasificación. Este artículo tiene como objetivo indicar la velocidad relativa del algoritmo de clasificación de burbujas. Esta velocidad relativa se conoce como complejidad del tiempo. La codificación se realiza en el lenguaje de la computadora C.
Contenido del artículo
- Introducción - Ver arriba
- Ilustración de clasificación de burbujas
- El peor rendimiento de los casos
- Mejor rendimiento para el tipo de burbujas
- Algunas secuencias de elementos intercalados ya ordenados
- Estuche perfecto
- Conclusión
Ilustración de clasificación de burbujas
Considere la siguiente lista no organizada:
R X F S U Z V JHay 8 elementos, que necesitan 8 escaneos completos, lo que resulta en:
R F S U X V J ZF r s u v j x z
F r s u j v x z
F r s j u v x z
F r j s u v x z
F j r s u v x z
F j r s u v x z
F j r s u v x z
El acuerdo de la lista final es el tipo completo.
El peor rendimiento de los casos
El código C para ordenar los ocho caracteres anteriores, previamente explicado es:
#incluirvacío bubblesort (char arr [], int n)
int contador = 0;
para (int i = 0; i < n; i++)
para (int j = 1; j < n; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
contador+= 1;
printf ("%i \ n", contador);
El código para el intercambio está en el bucle interno anidado. El contador cuenta el número de operaciones básicas. Los bucles externos de la bucle de 0 a 7, yo.mi., 8 veces. Los bucles internos para el bucle de 1 a 7, yo.mi., 7 veces. El número total de operaciones básicas (bucle interno) es 8 x 7 = 56. La salida de contador es 56.
Si el bucle interno de 0 a 7, entonces el número total de operaciones básicas habría sido 8 x 8 = 64. Este es el número máximo de operaciones básicas para este anidado para los bucles. Sea 8. Entonces, el número máximo de tales bucles de anidación es n2.
La peor complejidad del tiempo para la función anterior se da como,
En2)
La gran O seguida de sus paréntesis con n2 se llama la notación Big-O. Indica la velocidad relativa del código. Aunque en el código anterior, el número de operaciones básicas es 56, el número máximo posible de operaciones, 82 = 64, es lo que se daría para la complejidad del tiempo.
Una función principal C adecuada para el código anterior es:
int main (int argc, char ** argv)int n = 8;
char arr [] = 'r', 'x', 'f', 's', 'u', 'z', 'v', 'j';
Bubblesort (arr, n);
para (int i = 0; i
printf ("\ n");
regresar 0;
Mejor rendimiento para el tipo de burbujas
Aviso en la ilustración anterior para el tipo de burbuja; Después del primer escaneo, el elemento más alto está en el extremo derecho. Después del segundo escaneo, los dos elementos más altos están en el extremo derecho, en orden. Después del tercer escaneo, los tres elementos más altos están en el extremo derecho, en orden, y así sucesivamente. Las operaciones en estos elementos extremos de la derecha a medida que crecen se pueden omitir en la codificación. Esto aumentaría la velocidad general (tiempo para la clasificación completa). El siguiente código modificado ilustra esto:
vacío bubblesort (char arr [], int n)int contador = 0;
para (int i = 0; i < n; i++)
para (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
contador+= 1;
printf ("%i \ n", contador);
Esta vez, la salida de contador es 28. El número de operaciones básicas es 28, un poco menos de la mitad de 64, que es 32. Los bucles internos para el bucle de 1 a n - i. En su primer escaneo, i es cero y n - i = 8.
Ahora,
registro2 8 = registro2 23
= 3
8 x 3 = 8xlog2 23
= 24
que está cerca de 28. Sea n = 8. La última bitina de la expresión de operando derecha arriba se convierte en n.registro2 23, = n.registro2 8, generalmente escrito como, n log n.
Cuando la complejidad del tiempo está dentro de un rango medio, de 20 a 40, en este caso, se expresa como:
O (n log n)
Donde n es el número de elementos en la lista. Entonces, la complejidad del tiempo para el rendimiento mejorado de la clasificación de burbujas es n log n, lo que significa n x log2(norte).
Algunas secuencias de elementos intercalados ya ordenados
Hay ocho escaneos para la ilustración de clasificación de burbujas anterior. Observe que en el sexto escaneo, la lista ya estaba completamente ordenada. Las últimas dos filas son repeticiones de la sexta fila. Para esta lista no organizada en particular, los dos escaneos anteriores no eran necesarios. Esto sucede cuando la lista sin clasificar dada tiene algunas secuencias intercaladas ya ordenadas. Si la lista dada está completamente sin clasificar, la última fila sería la lista final ordenada (no sería una repetición del anterior).
Las últimas filas como las dos últimas anteriores se pueden omitir en la clasificación y, por lo tanto, mejorar el rendimiento (velocidad). El siguiente código ilustra esto:
vacío bubblesort (char arr [], int n)_Bool intercambiado = 0;
para (int i = 0; i < n; i++)
intercambiado = 0;
para (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
intercambiado = 1;
if (intercambiado == 0)
romper;
Estuche perfecto
El rendimiento perfecto ocurre cuando la lista dada ya está completamente ordenada. El código para probar esto es:
vacío bubblesort (char arr [], int n)int contador = 0;
_Bool intercambiado = 0;
para (int i = 0; i < n; i++)
intercambiado = 0;
para (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
intercambiado = 1;
contador+= 1;
if (intercambiado == 0)
romper;
printf ("%i \ n", contador);
La salida es:
7F j r s u v x z
Para una lista de entrada de,
F j r s u v x zEl 7 es del bucle interno. Sin embargo, para la complejidad del tiempo, se considera un máximo de 8. La complejidad del tiempo para un rendimiento perfecto se expresa como:
En)
Conclusión
En este artículo, discutimos la complejidad del tiempo de clasificación de burbujas y enfatizamos lo siguiente:
La peor complejidad del tiempo para el tipo de burbujas es:
En2)
Con la mejora del código, la complejidad del tiempo se convierte en:
O (n log n)
Cuando la lista dada ya está completamente ordenada, la complejidad del tiempo es:
En)