Visión general
Otros han dado buenos ejemplos de diagramas, como los diagramas de árbol. No vi ningún ejemplo de código simple. Entonces, además de mi explicación, proporcionaré algunos algoritmos con declaraciones de impresión simples para ilustrar la complejidad de las diferentes categorías de algoritmos.
Primero, querrás tener una idea general del Logaritmo, que puedes obtener en https://en.wikipedia.org/wiki/Logarithm . Uso de la ciencia natural ey el registro natural. Los discípulos de ingeniería usarán log_10 (log base 10) y los informáticos usarán log_2 (log base 2) mucho, ya que las computadoras están basadas en binarios. A veces verá abreviaturas de registro natural ln(), ya que los ingenieros normalmente dejan el _10 apagado y solo usan log()y log_2 se abrevia como lg(). Todos los tipos de logaritmos crecen de manera similar, es por eso que comparten la misma categoría de log(n).
Cuando mira los ejemplos de código a continuación, le recomiendo mirar O (1), luego O (n), luego O (n ^ 2). Después de que seas bueno con ellos, mira a los demás. He incluido ejemplos limpios, así como variaciones para demostrar cómo los cambios sutiles pueden resultar en la misma categorización.
Puedes pensar en O (1), O (n), O (logn), etc. como clases o categorías de crecimiento. Algunas categorías tomarán más tiempo que otras. Estas categorías nos ayudan a ordenar el rendimiento del algoritmo. Algunos crecieron más rápido a medida que aumenta la entrada n. La siguiente tabla demuestra dicho crecimiento numéricamente. En la siguiente tabla, piense en log (n) como el techo de log_2.
Ejemplos de código simple de varias categorías Big O:
O (1) - Ejemplos de tiempo constante:
El algoritmo 1 imprime hola una vez y no depende de n, por lo que siempre se ejecutará en tiempo constante, por lo que es así O(1).
print "hello";
El algoritmo 2 imprime hola 3 veces, sin embargo, no depende de un tamaño de entrada. Incluso cuando n crece, este algoritmo siempre imprimirá hola 3 veces. Dicho esto 3, es una constante, por lo que este algoritmo también lo es O(1).
print "hello";
print "hello";
print "hello";
O (log (n)) - Ejemplos logarítmicos:
- Algoritmo 3: esto actúa como "log_2"
El algoritmo 3 demuestra un algoritmo que se ejecuta en log_2 (n). Observe que la operación posterior del bucle for multiplica el valor actual de i por 2, por lo que iva de 1 a 2 a 4 a 8 a 16 a 32 ...
for(int i = 1; i <= n; i = i * 2)
print "hello";
- Algoritmo 4: esto actúa como "log_3"
El algoritmo 4 demuestra log_3. El aviso iva del 1 al 3 al 9 al 27 ...
for(int i = 1; i <= n; i = i * 3)
print "hello";
- Algoritmo 5: esto actúa como "log_1.02"
El algoritmo 5 es importante, ya que ayuda a demostrar que, siempre que el número sea mayor que 1 y el resultado se multiplique repetidamente contra sí mismo, está observando un algoritmo logarítmico.
for(double i = 1; i < n; i = i * 1.02)
print "hello";
O (n) - Ejemplos de tiempo lineal:
Este algoritmo es simple, que imprime hola n veces.
for(int i = 0; i < n; i++)
print "hello";
Este algoritmo muestra una variación, donde imprimirá hola n / 2 veces. n / 2 = 1/2 * n. Ignoramos la constante 1/2 y vemos que este algoritmo es O (n).
for(int i = 0; i < n; i = i + 2)
print "hello";
O (n * log (n)) - nlog (n) Ejemplos:
Piense en esto como una combinación de O(log(n))y O(n). La anidación de los bucles for nos ayuda a obtener elO(n*log(n))
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
El algoritmo 9 es como el algoritmo 8, pero cada uno de los bucles ha permitido variaciones, que aún dan como resultado que el resultado final sea O(n*log(n))
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
O (n ^ 2) - n al cuadrado Ejemplos:
O(n^2) se obtiene fácilmente anidando el estándar para bucles.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
Como el algoritmo 10, pero con algunas variaciones.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
O (n ^ 3) - n cubos Ejemplos:
Esto es como el algoritmo 10, pero con 3 bucles en lugar de 2.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
Como el algoritmo 12, pero con algunas variaciones que aún dan O(n^3).
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
Resumen
Lo anterior proporciona varios ejemplos directos y variaciones para ayudar a demostrar qué cambios sutiles se pueden introducir que realmente no cambian el análisis. Esperemos que te dé suficiente información.
