Cuando usamos notación asintótica para expresar la tasa de crecimiento del tiempo de ejecución de un algoritmo en términos del tamaño de la entrada n n , es bueno tener algunas cosas en mente.
Empecemos con algo sencillo. Supón que el algoritmo se tardó una cantidad constante de tiempo, sin importar el tamaño de su entrada. Por ejemplo, si te dieron un arreglo que ya está ordenado en orden ascendente y tienes que encontrar el elemento mínimo, te tomaría un tiempo constante, ya que el elemento mínimo debe estar en el índice 0. Como queremos usar una función de n n en notación asintótica, podrías decir que este algoritmo se ejecuta en un tiempo Θ(n0) \Theta(n^0) . ¿Por qué? Porque n0=1 n^0 = 1 y el tiempo de ejecución del algoritmo está dentro del rango de un factor constante de 1. Sin embargo, en la práctica, no escribimos Θ(n0) \Theta(n^0) ; escribimos Θ(1) \Theta(1) .
Ahora supón que un algoritmo tardó un tiempo Θ(log10n) \Theta (\log_{10} n) . También podrías decir que tardó un tiempo Θ(log2n) \Theta(\log_2 n) . Siempre que la base del logaritmo sea una constante, no importa qué base usemos en la notación asintótica. ¿Por qué no? Porque hay una fórmula matemática que dice:
logan=logbnlogba \displaystyle \log_a n = \dfrac{\log_b n}{\log_b a}
para todos los números positivos a a , b b y n n . Por lo tanto, si a a y b b son constantes, entonces logan \log_a n y logbn \log_b n difieren solo por un factor de logba \log_b a y ese es un factor constante que podemos ignorar en la notación asintótica.
Por lo tanto, podemos decir que el peor tiempo de ejecución de la búsqueda binaria es Θ(logan) \Theta(\log_a n) para cualquier constante positiva a a . ¿Por qué? El número de intentos es a lo más log2n+1 \log_2 n + 1 , generar y probar cada intento tarda un tiempo constante y configurar y regresar tarda un tiempo constante. Sin embargo, como cuestión de práctica, a menudo escribimos que esa búsqueda binaria tarda Θ(log2n) \Theta(\log_2 n) porque en ciencias de la computación nos gusta pensar en potencias de 2.
Hay un orden en las funciones que a menudo vemos cuando analizamos algoritmos usando notación asintótica. Si a a y b b son constantes y a<b a < b , entonces un tiempo de ejecución de Θ(na) \Theta(n^a) crece más despacio que un tiempo de ejecución de Θ(nb) \Theta(n^b) . Por ejemplo, un tiempo de ejecución de Θ(n) \Theta(n) , que es Θ(n1) \Theta(n^1) , crece más despacio que un tiempo de ejecución de Θ(n2) \Theta(n^2) . Los exponentes tampoco tienen que ser enteros. Por ejemplo, un tiempo de ejecución de Θ(n2) \Theta(n^2) crece más despacio que un tiempo de ejecución de Θ(n2n) \Theta(n^2 \sqrt{n}) , que es Θ(n2.5) \Theta(n^{2.5}) .
La siguiente gráfica comparas el crecimiento de nn,n2n^2 y n2.5n^{2.5}:
Gráfica que compara n, n cuadrada y n a la 2.5
Los logaritmos crecen más despacio que los polinomios. Eso es, Θ(log2n) \Theta(\log_2 n) crece más despacio que Θ(na) \Theta(n^a) para cualquier constante positiva a a . Pero como el valor de log2n \log_2 n crece a medida que n n crece, Θ(log2n) \Theta(\log_2 n) crece más rápido que Θ(1) \Theta(1) .
La siguiente gráfica compara el crecimiento de 11, nn y log2n\log_2 n:
Gráfica que compara 1, log base 2 de n y n
Aquí hay una lista de funciones en notación asintótica que a menudo encontramos cuando analizamos algoritmos, ordenadas de la que crece más despacio a la que crece más rápido:
  1. Θ(1) \Theta(1)
  2. Θ(log2n) \Theta(\log_2 n)
  3. Θ(n) \Theta(n)
  4. Θ(nlog2n) \Theta(n \log_2 n)
  5. Θ(n2) \Theta(n^2)
  6. Θ(n2log2n) \Theta(n^2 \log_2 n)
  7. Θ(n3) \Theta(n^3)
  8. Θ(2n) \Theta(2^n)
  9. Θ(n!) \Theta(n!)
Observa que la función exponencial ana^n, donde a>1a > 1, crece más rápido que cualquier función polinomial nb n^b , donde b b es cualquier constante.
La lista anterior no es exhaustiva, hay muchas funciones más con tiempos de ejecución que no están listadas aquí. Con suerte te las encontrarás en tu viaje por las ciencias de la computación.

Este contenido es una colaboración de los profesores de Dartmouth Computer Science Thomas Cormen y Devin Balkcom, con el equipo de contenidos de computación de Khan Academy. El contenido está bajo licencia CC-BY-NC-SA.
Cargando