¿Cómo encontrar la complejidad temporal de un algoritmo?

He pasado por Google y desbordamiento de pila búsqueda, pero en ninguna parte pude encontrar una explicación clara y sencilla de cómo calcular la complejidad del tiempo

¿Qué sé ya?

Digamos por un código tan simple como el siguiente:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

Diga para un bucle como el siguiente:

for (int i = 0; i < N; i++) {
    Console.Write('Hello World !');
}
  • int i=0; Esto se ejecutará solo una vez. El tiempo se calcula realmente para i=0 y no la declaración.
  • i < N; Esto se ejecutará N + 1 veces
  • i++ Esto se ejecutará N veces

Entonces, el número de operaciones requeridas por este ciclo es {1+(N+1)+N} = 2N+2. (Pero esto todavía puede estar mal, ya que no estoy seguro de mi comprensión).

Bien, estos pequeños cálculos básicos creo que los sé, pero en la mayoría de los casos he visto la complejidad del tiempo como O(N), O(n^2), O(log n), O(n!), Y muchos otros.

preguntado el 14 de junio de 12 a las 12:06

Bonificación para los interesados: The Big O Cheat Sheet bigochachesheet.com -

Mira este blog: mohalgorithmsorbit.blogspot.com. Cubre tanto algoritmos recursivos como (especialmente) iterativos. -

¿Por qué Console.Write('Hello World!'); ¿No es una instrucción de máquina? -

@Chetan Si quieres decir que deberías considerar Console.Write al calcular la complejidad, eso es cierto, pero también algo irrelevante en este caso, ya que eso solo cambia un factor constante, que Big-O ignora (ver las respuestas), por lo que el resultado final sigue siendo una complejidad de O (N). -

9 Respuestas

Cómo encontrar la complejidad temporal de un algoritmo

Suma cuántas instrucciones de máquina ejecutará en función del tamaño de su entrada y luego simplifica la expresión al término más grande (cuando N es muy grande) y puede incluir cualquier factor constante de simplificación.

Por ejemplo, veamos cómo simplificamos 2N + 2 instrucciones de la máquina para describir esto como simplemente O(N).

¿Por qué quitamos los dos? 2s?

Estamos interesados ​​en el rendimiento del algoritmo a medida que N se vuelve grande.

Considere los dos términos 2N y 2.

¿Cuál es la influencia relativa de estos dos términos cuando N se hace grande? Supongamos que N es un millón.

Entonces el primer término es 2 millones y el segundo término es solo 2.

Por esta razón, eliminamos todos los términos excepto los más grandes para N grande.

Entonces, ahora hemos pasado de 2N + 2 a 2N.

Tradicionalmente, solo nos interesa el rendimiento. hasta factores constantes.

Esto significa que realmente no nos importa si hay algún múltiplo constante de diferencia en el rendimiento cuando N es grande. De todos modos, la unidad de 2N no está bien definida en primer lugar. Entonces podemos multiplicar o dividir por un factor constante para llegar a la expresión más simple.

So 2N se vuelve justo N.

respondido 29 mar '17, 12:03

oye, gracias por dejarme saber "por qué O (2N + 2) a O (N)" muy bien explicado, pero esto era solo una parte de la pregunta más grande, quería que alguien señalara algún enlace a un recurso oculto o en En general, quería saber cómo terminar con complejidades de tiempo como O(N), O(n2), O(log n), O(n!), etc. Sé que puedo estar preguntando mucho, pero todavía puedo probar :{) - Yasser Shaikh

Bueno, la complejidad entre paréntesis es cuánto tarda el algoritmo, simplificado usando el método que he explicado. Calculamos cuánto tarda el algoritmo simplemente sumando el número de instrucciones de máquina que ejecutará. Podemos simplificar mirando solo los bucles más ocupados y dividiendo por factores constantes como he explicado. - Andrés Tomazos

Dar un ejemplo en respuesta habría ayudado mucho a los futuros lectores. Solo entregar un enlace para el cual tengo que registrarme, realmente no me ayuda cuando solo quiero leer un texto bien explicado. - malos_puntos_clave

Sugeriría ver los videos del Dr. Naveen Garg (IIT Delhi Prof.) si desea obtener un buen conocimiento sobre DS y la complejidad del tiempo. Consulte el enlace.nptel.ac.in/courses/106102064 - Rohit Bandil

(cont.) Esta jerarquía tendría una altura del orden de log N. En cuanto a O(N!), es probable que mis analogías no sean suficientes, pero las permutaciones son de ese orden: es prohibitivamente empinada, más que cualquier polinomio o exponencial. ¡Son exactamente 10! segundos en seis semanas pero el universo es menos de 20! segundos de antigüedad. - John P

Éste es un artículo excelente : http://www.daniweb.com/software-development/computer-science/threads/13488/time-complexity-of-algorithm

La siguiente respuesta se copia de arriba (en caso de que el excelente enlace se rompa)

La métrica más común para calcular la complejidad del tiempo es la notación Big O. Esto elimina todos los factores constantes para que el tiempo de ejecución se pueda estimar en relación con N a medida que N se acerca al infinito. En general, puedes pensarlo así:

statement;

es constante El tiempo de ejecución de la declaración no cambiará en relación con N.

for ( i = 0; i < N; i++ )
     statement;

es lineal. El tiempo de ejecución del bucle es directamente proporcional a N. Cuando N se duplica, también lo hace el tiempo de ejecución.

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

es cuadrática. El tiempo de ejecución de los dos bucles es proporcional al cuadrado de N. Cuando N se duplica, el tiempo de ejecución aumenta en N * N.

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

es logarítmico. El tiempo de ejecución del algoritmo es proporcional al número de veces que N se puede dividir por 2. Esto se debe a que el algoritmo divide el área de trabajo por la mitad con cada iteración.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

Es N * registro ( N ). El tiempo de ejecución consta de N bucles (iterativos o recursivos) que son logarítmicos, por lo que el algoritmo es una combinación de lineal y logarítmico.

En general, hacer algo con cada elemento en una dimensión es lineal, hacer algo con cada elemento en dos dimensiones es cuadrático y dividir el área de trabajo por la mitad es logarítmico. Hay otras medidas de Big O, como la cúbica, la exponencial y la raíz cuadrada, pero no son tan comunes. La notación Big O se describe como O ( <type> ) sin que importe <type> es la medida. El algoritmo de clasificación rápida se describiría como O ( N * log ( N ) ).

Tenga en cuenta que nada de esto ha tenido en cuenta las medidas del mejor, promedio y peor de los casos. Cada uno tendría su propia notación Big O. También tenga en cuenta que esta es una explicación MUY simplista. Big O es el más común, pero también es más complejo de lo que he mostrado. También hay otras notaciones como omega grande, o pequeña y theta grande. Probablemente no los encontrará fuera de un curso de análisis de algoritmos. ;)

contestado el 04 de mayo de 20 a las 23:05

La ordenación rápida algoritmo en el peor de los casos tiene un tiempo de ejecución de N ^ 2, aunque este comportamiento es raro. - hermano

IIRC, little o y big omega se utilizan para la complejidad del caso mejor y promedio (siendo O grande el peor de los casos), por lo que "medidas del mejor, promedio y peor caso. Cada uno tendría su propia notación Big O". sería incorrecto. Incluso hay más símbolos con significados más específicos, y CS no siempre usa el símbolo más apropiado. Llegué a aprender todo esto por el nombre Símbolos Landau por cierto. +1 de todos modos b/c mejor respuesta. - hiergiltdiestfu

@hiergiltdiestfu Big-O, Big-Omega, etc. se pueden aplicar a cualquiera de los mejores, promedios o peores tiempos de ejecución de un algoritmo. ¿Cómo se relacionan O y Ω con el peor y el mejor de los casos? - Bernardo Barker

Además, si alguien está buscando cómo calcular O grande para cualquier método: stackoverflow.com/a/60354355/4260691 - OhadM

Una de las mejores explicaciones. - Shivaraj Patil

Tomado de aquí - Introducción a la complejidad temporal de un algoritmo

1. Introducción

En informática, la complejidad temporal de un algoritmo cuantifica la cantidad de tiempo que tarda un algoritmo en ejecutarse en función de la longitud de la cadena que representa la entrada.

2. Notación O grande

La complejidad temporal de un algoritmo se expresa comúnmente mediante la notación O grande, que excluye los coeficientes y los términos de orden inferior. Cuando se expresa de esta manera, se dice que la complejidad del tiempo se describe asintóticamente, es decir, cuando el tamaño de entrada tiende a infinito.

Por ejemplo, si el tiempo requerido por un algoritmo en todas las entradas de tamaño n es como máximo 5n3 + 3n, la complejidad temporal asintótica es O(n3). Más sobre eso más adelante.

Algunos ejemplos más:

  • 1 = O(n)
  • n = O(n2)
  • registro(n) = O(n)
  • 2 norte + 1 = O(n)

3. O(1) Tiempo constante:

Se dice que un algoritmo se ejecuta en tiempo constante si requiere la misma cantidad de tiempo independientemente del tamaño de entrada.

Ejemplos:

  • matriz: accediendo a cualquier elemento
  • pila de tamaño fijo: métodos push y pop
  • cola de tamaño fijo: métodos de poner y quitar cola

4. O(n) Tiempo lineal

Se dice que un algoritmo se ejecuta en tiempo lineal si su tiempo de ejecución es directamente proporcional al tamaño de entrada, es decir, el tiempo crece linealmente a medida que aumenta el tamaño de entrada.

Considere los siguientes ejemplos, a continuación estoy buscando linealmente un elemento, esto tiene una complejidad de tiempo de O (n).

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

Más ejemplos:

  • Matriz: búsqueda lineal, recorrido, búsqueda mínima, etc.
  • ArrayList: contiene el método
  • Cola: contiene el método

5. O(log n) Tiempo logarítmico:

Se dice que un algoritmo se ejecuta en tiempo logarítmico si su tiempo de ejecución es proporcional al logaritmo del tamaño de entrada.

Ejemplo: Búsqueda binaria

Recuerde el juego de las "veinte preguntas": la tarea es adivinar el valor de un número oculto en un intervalo. Cada vez que haga una conjetura, se le indicará si su conjetura es demasiado alta o demasiado baja. El juego de veinte preguntas implica una estrategia que utiliza su número de conjetura para reducir a la mitad el tamaño del intervalo. Este es un ejemplo del método general de resolución de problemas conocido como búsqueda binaria.

6. O(n2) Tiempo cuadrático

Se dice que un algoritmo se ejecuta en tiempo cuadrático si su tiempo de ejecución es proporcional al cuadrado del tamaño de entrada.

Ejemplos:

7. Algunos enlaces útiles

Respondido el 20 de junio de 20 a las 10:06

Nota: el primer enlace está roto. - Ziezi

O(n2) debe escribirse O(n^2) para evitar confusiones. - Rizki Hadiaturrasyid

Aunque hay algunas buenas respuestas para esta pregunta. Me gustaría dar otra respuesta aquí con varios ejemplos de loop.

  • O (n): La complejidad temporal de un bucle se considera como O (n) si las variables del bucle se incrementan/disminuyen en una cantidad constante. Por ejemplo, las siguientes funciones tienen O (n) complejidad del tiempo.

    // Here c is a positive integer constant   
    for (int i = 1; i <= n; i += c) {  
        // some O(1) expressions
    }
    
    for (int i = n; i > 0; i -= c) {
        // some O(1) expressions
    }
    
  • O(n^c): La complejidad temporal de los bucles anidados es igual al número de veces que se ejecuta la instrucción más interna. Por ejemplo, los siguientes bucles de muestra tienen O (n ^ 2) complejidad de tiempo

    for (int i = 1; i <=n; i += c) {
       for (int j = 1; j <=n; j += c) {
          // some O(1) expressions
       }
    }
    
    for (int i = n; i > 0; i += c) {
       for (int j = i+1; j <=n; j += c) {
          // some O(1) expressions
    }
    

    Por ejemplo, la ordenación por selección y la ordenación por inserción tienen O (n ^ 2) complejidad del tiempo.

  • O (Logn) La complejidad temporal de un bucle se considera como O (Logn) si las variables del bucle se dividen/multiplican por una cantidad constante.

    for (int i = 1; i <=n; i *= c) {
       // some O(1) expressions
    }
    for (int i = n; i > 0; i /= c) {
       // some O(1) expressions
    }
    

    Por ejemplo, la búsqueda binaria tiene O (Logn) complejidad del tiempo.

  • O(Iniciar sesión) La complejidad temporal de un bucle se considera como O(Iniciar sesión) si las variables del bucle se reducen/aumentan exponencialmente en una cantidad constante.

    // Here c is a constant greater than 1   
    for (int i = 2; i <=n; i = pow(i, c)) { 
       // some O(1) expressions
    }
    //Here fun is sqrt or cuberoot or any other constant root
    for (int i = n; i > 0; i = fun(i)) { 
       // some O(1) expressions
    }
    

Un ejemplo de análisis de la complejidad del tiempo

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

Análisis:

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

Entonces, la complejidad temporal total del algoritmo anterior es (n + n/2 + n/3 + … + n/n), que se convierte n * (1/1 + 1/2 + 1/3 + … + 1/n)

Lo importante de la serie. (1/1 + 1/2 + 1/3 + … + 1/n) es igual a O (Logn). Entonces, la complejidad temporal del código anterior es O(nIniciar sesión).


Ref: 1 2 3

respondido 02 nov., 15:09

@Simon, ¿podría averiguar qué parte es incorrecta? - zangw

gracias por preguntar. Leí mal el código. Borré mi comentario. ¡Lo siento! - Simon

en el análisis debería ser O(n ^ 2) . - Koustuv Ganguly

Complejidad del tiempo con ejemplos

1 - Operaciones básicas (aritmética, comparaciones, acceso a los elementos de la matriz, asignación): el tiempo de ejecución es siempre constante O (1)

Ejemplo:

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - Sentencia if, else: Tomando sólo el tiempo máximo de ejecución de dos o más sentencias posibles.

Ejemplo:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

Entonces, la complejidad del pseudocódigo anterior es T(n) = 2 + 1 + max(1, 1+2) = 6. Por lo tanto, su gran oh sigue siendo constante T(n) = O(1).

3 - Bucles (for, while, repeat): El tiempo de ejecución de esta declaración es el número de bucles multiplicado por el número de operaciones dentro de ese bucle.

Ejemplo:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

Entonces, su complejidad es T(n) = 1+4n+1 = 4n + 2. Por lo tanto, T(n) = O(n).

4 - Bucle anidado (bucle dentro del bucle): dado que hay al menos un bucle dentro del bucle principal, el tiempo de ejecución de esta declaración usó O (n ^ 2) u O (n ^ 3).

Ejemplo:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

Tiempo de ejecución común

Hay algunos tiempos de ejecución comunes cuando se analiza un algoritmo:

  1. O(1) – Tiempo constante Tiempo constante significa que el tiempo de ejecución es constante, es no afectado por el tamaño de entrada.

  2. O(n) – Tiempo lineal Cuando un algoritmo acepta n tamaño de entrada, también realizará n operaciones.

  3. O(log n) – Algoritmo de tiempo logarítmico que tiene un tiempo de ejecución O(log n) ligeramente más rápido que O(n). Comúnmente, el algoritmo divide el problema en subproblemas del mismo tamaño. Ejemplo: algoritmo de búsqueda binaria, algoritmo de conversión binaria.

  4. O(n log n) – Tiempo lineal Este tiempo de ejecución se encuentra a menudo en "algoritmos de divide y vencerás" que dividen el problema en subproblemas recursivamente y luego los fusionan en n tiempo. Ejemplo: Algoritmo Merge Sort.

  5. En2) – ¡Algoritmo cuadrático de clasificación de burbujas de tiempo!

  6. En3) – Tiempo Cúbico Tiene el mismo principio con O(n2).

  7. O (2n) – Tiempo exponencial Es muy lento a medida que la entrada aumenta, si n = 1000.000, T(n) sería 21000.000. El algoritmo de fuerza bruta tiene este tiempo de ejecución.

  8. O(n!) – Tiempo Factorial EL MAS LENTO !!! Ejemplo: Problema del vendedor de viajes (TSP)

Tomado de este artículo. Muy bien explicado debería dar una lectura.

Respondido 25 Feb 15, 14:02

En tu segundo ejemplo, escribiste visitors = visitors + 1 is 1 + 1 = 2. ¿Podrías explicarme por qué hiciste eso? - Sajib Acharya

@Sajib Acharya Míralo de derecha a izquierda. Primer paso: calcular visitors + 1 Segundo paso: asignar valor del primer paso a visitors Entonces, la expresión anterior está formada por dos declaraciones; primer paso + segundo paso => ​​1+1=2 - Bozidar Sikanjic

@nbro ¿Por qué es 1+1 en age = read(x) // (1+1) = 2 - humty

@BozidarSikanjic Por qué es 1+1 en age = read(x) // (1+1) = 2 - humty

@Humty Verifique el comienzo de esta respuesta: read(x) // O(1) a = 10; // O(1) La primera es la llamada a la función => O(1) ///// La segunda es la asignación, como dijo nbro, pero 10 es constante, por lo que la segunda es => O(1)... - Bozidar Sikanjic

Cuando está analizando el código, debe analizarlo línea por línea, contando cada operación/reconociendo la complejidad del tiempo, al final, debe sumarlo para obtener una imagen completa.

Por ejemplo, puede tener un bucle simple con complejidad lineal, pero luego en ese mismo programa puedes tener un bucle triple que tiene complejidad cúbica, por lo que su programa tendrá complejidad cúbica. El orden de función de crecimiento entra en juego aquí mismo.

Veamos cuáles son las posibilidades para la complejidad temporal de un algoritmo, puede ver el orden de crecimiento que mencioné anteriormente:

  • Tiempo constante tiene un orden de crecimiento 1, Por ejemplo: a = b + c.

  • tiempo logarítmico tiene un orden de crecimiento LogN, generalmente ocurre cuando divide algo por la mitad (búsqueda binaria, árboles, incluso bucles) o multiplica algo de la misma manera.

  • Lineal, el orden de crecimiento es N, Por ejemplo

    int p = 0;
    for (int i = 1; i < N; i++)
      p = p + 2;
    
  • Linearítmico, el orden de crecimiento es n*logN, generalmente ocurre en los algoritmos de divide y vencerás.

  • Cúbico, orden de crecimiento N^3, el ejemplo clásico es un bucle triple en el que comprueba todos los trillizos:

    int x = 0;
    for (int i = 0; i < N; i++)
       for (int j = 0; j < N; j++)
          for (int k = 0; k < N; k++)
              x = x + 2
    
  • Exponencial, orden de crecimiento 2^N, generalmente ocurre cuando realiza una búsqueda exhaustiva, por ejemplo, verifica subconjuntos de algún conjunto.

Respondido el 17 de junio de 17 a las 08:06

Si este fuera el caso, ¿cuál sería la complejidad? para (int i = 0; i < N; i++) para (int j = i+1; j < N; j++) para (int k = j+1; k < N; k++) x = x + 2 - user3156040

En términos generales, la complejidad del tiempo es una forma de resumir cómo crece la cantidad de operaciones o el tiempo de ejecución de un algoritmo a medida que aumenta el tamaño de entrada.

Como la mayoría de las cosas en la vida, un cóctel puede ayudarnos a comprender.

EN)

Cuando llegas a la fiesta, tienes que estrechar la mano de todos (hacer una operación en cada artículo). Como el número de asistentes N aumenta, el tiempo/trabajo que le tomará estrechar la mano de todos aumenta a medida que O(N).

Por qué O(N) y no cN?

Existe una variación en la cantidad de tiempo que lleva estrechar la mano de las personas. Podrías promediar esto y capturarlo en una constante c. Pero la operación fundamental aquí --- dar la mano a todos --- sería siempre proporcional a O(N), no importa qué c era. Cuando debatimos si deberíamos ir a un cóctel, a menudo nos interesa más el hecho de que tendremos que reunirnos con todos que los detalles minuciosos de cómo serán esas reuniones.

O (N ^ 2)

El anfitrión del cóctel quiere que juegues un juego tonto en el que todos se encuentran con los demás. Por lo tanto, debe cumplir N-1 otras personas y, debido a que la siguiente persona ya te ha conocido, debe conocerte N-2 gente, y así sucesivamente. La suma de esta serie es x^2/2+x/2. A medida que crece el número de asistentes, la x^2 el término se hace grande rápido, así que dejamos todo lo demás.

O (N ^ 3)

Tienes que conocer a todos los demás y, durante cada reunión, debes hablar sobre todos los demás en la sala.

O (1)

El anfitrión quiere anunciar algo. Tocan una copa de vino y hablan en voz alta. Todos los escuchan. Resulta que no importa cuántos asistentes haya, esta operación siempre lleva la misma cantidad de tiempo.

O (log N)

El anfitrión ha colocado a todos en la mesa en orden alfabético. ¿Dónde está Dan? Usted razona que debe estar en algún lugar entre Adam y Mandy (¡ciertamente no entre Mandy y Zach!). Dado eso, ¿está entre George y Mandy? No. Debe estar entre Adam y Fred, y entre Cindy y Fred. Y así sucesivamente... podemos localizar a Dan eficientemente mirando la mitad del conjunto y luego la mitad de ese conjunto. En definitiva, miramos O(registro_2 N) individuos

O (N log N)

Puede encontrar dónde sentarse en la mesa usando el algoritmo anterior. Si un gran número de personas se sentara a la mesa, una a la vez, y todas hicieran esto, eso llevaría O (N log N) hora. Esto resulta ser el tiempo que se tarda en clasificar cualquier colección de elementos cuando deben compararse.

Mejor/peor caso

Llegas a la fiesta y necesitas encontrar a Iñigo. ¿Cuánto tardarás? Depende de cuando llegues. Si todo el mundo está dando vueltas, ha llegado al peor de los casos: le llevará O(N) hora. Sin embargo, si todos están sentados a la mesa, solo tomará O(log N) hora. O tal vez pueda aprovechar el poder de gritar copas de vino del anfitrión y solo tomará O(1) en las transacciones.

Suponiendo que el host no está disponible, podemos decir que el algoritmo de búsqueda de Íñigo tiene un límite inferior de O(log N) y un límite superior de O(N), dependiendo del estado de la fiesta cuando llegue.

Espacio y Comunicación

Las mismas ideas se pueden aplicar para comprender cómo los algoritmos usan el espacio o la comunicación.

Knuth ha escrito un buen artículo sobre el primero titulado "La complejidad de las canciones".

Teorema 2: Existen cantos arbitrariamente largos de complejidad O(1).

PRUEBA: (debido a Casey and the Sunshine Band). Considere las canciones Sk definidas por (15), pero con

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

para todo k.

Respondido 14 Oct 15, 05:10

Lo has clavado. Ahora, cada vez que voy a un cóctel, inconscientemente intentaré encontrar la Complejidad del Tiempo de cualquier evento divertido. Gracias por un ejemplo tan divertido. - Sabunkar Tejas Sahailesh

Sé que esta pregunta se remonta a mucho tiempo atrás y hay algunas respuestas excelentes aquí, sin embargo, quería compartir otro poco para las personas con mentalidad matemática que tropezarán en esta publicación. El Teorema maestro es otra cosa útil para saber cuando se estudia la complejidad. No lo vi mencionado en las otras respuestas.

respondido 04 nov., 15:09

O(n) es la notación O grande utilizada para escribir la complejidad temporal de un algoritmo. Cuando sumas el número de ejecuciones en un algoritmo, obtendrás una expresión como resultado 2N+2, en esta expresión N es el término dominante (el término que tiene el mayor efecto en la expresión si su valor aumenta o disminuye). Ahora O(N) es la complejidad del tiempo mientras que N es el término dominante. Ejemplo

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

aquí el número total de ejecuciones para el ciclo interno es n+1 y el número total de ejecuciones para el ciclo externo es n(n+1)/2, por lo que el número total de ejecuciones para el algoritmo completo es n+1+n(n+1/2 ) = (n^2+3n)/2. aquí n ^ 2 es el término dominante, por lo que la complejidad de tiempo para este algoritmo es O (n ^ 2)

respondido 11 mar '13, 20:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.