2008-10-19 11 views
27

Para la tarea, me dieron los siguientes 8 fragmentos de código para analizar y dar una notación Big-Oh para el tiempo de ejecución. ¿Alguien puede decirme si estoy en el camino correcto?Big O Notation Homework - ¿Análisis de Algoritmo de Fragmentos de Código?

//Fragment 1 
for(int i = 0; i < n; i++) 
    sum++; 

estoy pensando O (N) para el fragmento 1

//Fragment 2 
for(int i = 0; i < n; i+=2) 
    sum++; 

O (N) para el fragmento 2, así

//Fragment 3 
for(int i = 0; i < n; i++) 
    for(int j = 0; j < n; j++) 
     sum++; 

O (N^2) para el fragmento 3

//Fragment 4 
for(int i = 0; i < n; i+=2) 
    sum++; 
for(int j = 0; j < n; j++) 
    sum++; 

O (N) para el fragmento 4

//Fragment 5 
for(int i = 0; i < n; i++) 
    for(int j = 0; j < n * n; j++) 
     sum++; 

O (N^2) para el fragmento 5 pero el n * n me está lanzando fuera un poco así que no estoy muy seguro de

//Fragment 6 
for(int i = 0; i < n; i++) 
    for(int j = 0; j < i; j++) 
     sum++; 

O (N^2) para el fragmento 6 como así

//Fragment 7 
for(int i = 0; i < n; i++) 
    for(int j = 0; j < n * n; j++) 
     for(int k = 0; k < j; k++) 
      sum++; 

O (N^3) para el fragmento 7 pero una vez más el n * n me está lanzando fuera

//Fragment 8 
for(int i = 1; i < n; i = i * 2) 
    sum++; 

O (N) para el fragmento 8

+0

No estoy de acuerdo con el comentario "demasiado localizado". El cálculo de Big-Oh es una parte central del análisis de algoritmos. Los ejemplos de códigos específicos con estimaciones de Big-Oh pueden ser extremadamente valiosos para las personas que intentan hablar con fluidez en esta área. – JESii

Respuesta

20

Creo que el fragmento 5 es O (n^3), y el fragmento 7 es O (n^5) *. También se ve como O (log (n)) para el fragmento 8.

Para los n * n problemas, debe ejecutar el cuerpo del ciclo n * n veces, por lo que sería O (n^2) , entonces compones eso con el orden del otro código. Fragmento 8 se duplica el contador en lugar de incrementarlo, por lo que cuanto mayor sea el problema, el trabajo menos adicional que tiene que hacer, por lo que es O (log (n))

* Editar: fragmento 7 es O (n^5), no O (n^4) como yo pensaba anteriormente. Esto se debe a que tanto j como k van de 1 a n * n. Perdón, no entendí esto antes.

+0

¡oh bien, veo lo que dices! Entonces para 5, el n * n significa que el cuerpo del bucle interno se ejecutará en orden de N^2 veces y compilando eso con el orden de N para el bucle externo, en general será O (N^3). – VeePee

+0

misma idea para el fragmento 7. Hombre, el fragmento 8 fue completamente por encima de mi cabeza. Lo siento si esto es pedir demasiado, pero tengo curiosidad por ¿cómo sería el código de O (Nlog (N)) en caso de que alguna vez lo encuentre? – VeePee

+1

Para un algoritmo O (n * log (n)), imagine un bucle externo que cuente de 1 a ny un bucle interno que vaya de 1 a n multiplicando el contador por 2 cada vez. Sin embargo, es extremadamente inusual encontrar tales algoritmos. Los algoritmos O (n * log (n)) más comunes son QuickSort y Merge Sort. –

0

Parece que está en el camino correcto. Con respecto al N * N, ¿qué efecto crees que tendría? Es otro factor de N, por lo que probablemente sea un orden superior.

Solo una advertencia, vi otra publicación como esta y fue muy rechazada. Ten cuidado. Here es la publicación.

+0

En realidad superé la pregunta, ya que él (1) obviamente ha hecho un intento serio para resolver los problemas y (2) fue honesto acerca de que se tratara de una tarea. – JesperE

+0

Oh, definitivamente estoy de acuerdo, este es un intento sólido del problema y una pregunta válida. Solo quiero advertirle en caso de que otros reaccionen mal. Aunque en este caso él debería estar bien. – smaclell

2

Para el caso 8 intentar escribir el número de iteraciones para algunos valores de N y ver lo que el patrón parece ... no es O (N)

7

Fragmento 7 es O (n^5) , no O (n^4) como afirma el comentario actualmente aceptado. De lo contrario, es correcto.

+0

Gracias por la captura que –

+0

Claro. Ese es el beneficio de un sitio colaborativo. –

0

Estás en el camino correcto, pero aquí hay un consejo sobre cómo las cosas podrían aclararse en el camino. Supongamos que tiene algún código:

for(i = 0; i < n; i++) { 
    for(j = 0; j < 100; j++){....} 
} 

Derecho, considere el hecho de que tiene código en diferentes niveles.En este ejemplo, sólo se puede ver 3 niveles hasta ahora:

  1. El exterior de bucle que va desde 0-n
  2. Otra para-bucle que va de 0-100
  3. Algunos código dentro, que está marcado como ...

En ningún momento debe intentar calcularlo todo en 1 tiempo. Aquí es donde la mayoría de los principiantes cometen algún tipo de error aritmético. Calcúlelo individualmente para cada nivel y luego multiplíquelo todo junto.

¡Buena suerte!