Algoritmo-tiempo frecuencia y complejidad del tiempo y complejidad del espacio

Tiempo de ejecución del algoritmo de cálculo

• Frecuencia temporal: el tiempo empleado por un algoritmo es proporcional al número de ejecuciones de oraciones en el algoritmo. El número de ejecuciones de oraciones en el algoritmo se llama frecuencia de oración o frecuencia de tiempo. La frecuencia de tiempo está representada por T (n)
• Calcula la suma de todos los números del 1 al 100, calculada mediante dos algoritmos:

int total = 0;
int end = 100;

# 使用 for循环计算
for (i = 1; i <= end; i++) {
 total += i;
}
- 以上算法的时间频度是 T(n)=n+1

# 不通过循环, 而直接计算
total = (1 + end) * end / 2;
- 以上算法的时间频度是 T(n)=1

• A medida que n se vuelve más grande, hay 3 características (3 elementos que se pueden ignorar):

1. Término constante

(1) A medida que n aumenta, el intervalo de tiempo de ejecución de 2n + 20 y 2n es infinitamente cercano, por lo que 20 se puede ignorar
(2) A medida que n aumenta, el intervalo de tiempo de ejecución es infinitamente cercano, por lo que 10 se puede ignorar

2. Términos de bajo orden

(1) 2n ^{2 + 3n + 10 y 2n} 2 se vuelven infinitamente cercanos a medida que n se hace más grande, por lo que 3n + 10 se puede ignorar.
(2) n ^{2 + 5n + 20 y n} 2 se vuelven más grandes a medida que n aumenta, El intervalo de tiempo de ejecución es infinitamente cercano, se pueden ignorar 5n + 20

3. coeficiente

(1) A medida que n se hace más grande, el intervalo de tiempo de ejecución de 5n ^ 2 + 7n y 3n ^ 2 + 2n es infinitamente cercano, y 5 y 3 pueden ignorarse en este momento.
(2) Sin embargo, n ^ 3 + 5n y 6n ^ 3 + 4n El intervalo de tiempo de ejecución se separará, y la clave es cuántos poderes se pueden encontrar

Complejidad del tiempo

• Velocidad de ejecución del algoritmo, depende principalmente de la complejidad del tiempo

1. En general, el número de ejecuciones repetidas del enunciado de operación básica en el algoritmo es una función determinada de la escala del problema n, representada por T (n), si hay una función auxiliar f (n), de modo que cuando n se acerca al infinito, El valor límite de T (n) / f (n) es una constante que no es igual a cero, por lo que f (n) es una función del mismo orden de magnitud de T (n). Denotado como T (n) = O (f (n)), O (f (n)) es la complejidad temporal progresiva del algoritmo, denominada complejidad temporal

• Ejemplo: T (n) = n2 + 7n + 6 y T (n) = 3n2 + 2n + 2, su T (n) es diferente, pero la complejidad del tiempo es la misma. Ambos son O (n2)
• Método de cálculo:
  (1) Reemplace todas las constantes aditivas en el tiempo de ejecución con una constante 1 T (n) = n2 + 7n + 6 → T (n) = n2 + 7n + 1
  (2) En la función de frecuencia de ejecución modificada, solo Mantener el término de mayor orden T (n) = n2 + 7n + 1 → T (n) = n2
  (3) Quitar el coeficiente del término de mayor orden T (n) = n2 → T (n) = n2 → O (n2)

• 8 complejidad de tiempo común, de pequeña a grande:

1. Orden constante O (1)
2. Orden logarítmico O (log2n)
3. Orden lineal O (n)
4. Orden logarítmico lineal O (nlog2n)
5. Orden cuadrado O (n ^ 2)
6. Orden cúbico O (n ^ 3)
7. k-ésimo orden O (n ^ k)
8. Orden exponencial O (2 ^ n)

• Con el aumento continuo de n, la complejidad de tiempo mencionada anteriormente continúa aumentando, y la eficiencia de ejecución del algoritmo será cada vez menor.

Orden constante O (1)

• No importa cuántas líneas de código, siempre que haya estructuras complejas como bucles, la complejidad de tiempo de este código es O (1)

int a = 1;
int b = 2;
++a;
b++;
int c = a + b;

• Cuando se ejecuta el código anterior, el tiempo consumido no aumenta con el crecimiento de una determinada variable, por lo que no importa cuántas líneas de dicho código haya, O (1) se puede usar para representar la complejidad del tiempo.

Orden logarítmico O (log2n)

int a = 1;
while (a < n) {
   a = a * 2;
}

• El while del código anterior multiplica a por 2 cada vez que se repite y luego asigna el resultado a a. Por lo tanto, se acercará cada vez más al tamaño de n. Suponiendo que después del ciclo x veces, a es mayor o igual que n, el ciclo termina en este momento, que es La potencia x de 2 es igual an (x = log2n), es decir, el bucle termina después de repetir log2n veces
• En O (log2n), 2 es la base, n es el número verdadero y la base se puede cambiar. Si 2 se cambia a 3 a = a * 3, se puede marcar como O (log3n)

Orden lineal O (n)

for (int i = 1; i <= n; ++i) {
   i++;
}

• El código en el bucle for en el código anterior se ejecutará n veces, por lo que el tiempo que consume varía con el cambio de n, por lo que este tipo de código se puede representar por O (n)

Orden logarítmico lineal O (nlog2n)

• El orden logarítmico lineal O (nlogN) es un algoritmo que repite el código con una complejidad de tiempo de O (logn) N veces, es decir, el n * O (logN) anidado de orden lineal y orden logarítmico

for (int m =1; m < n; m++) {
   i = 1;
   while (i < n) {
        i = i * 2;
   }
}

Orden cuadrado O (n2)

• El orden cuadrado está anidado con 2 niveles de n ciclos, que son 2 niveles de orden lineal, es decir, O (n²). Si cambia el n de uno de los ciclos a m, entonces su complejidad de tiempo es O (mn)

int m = 1;
for (int i = 1; i <= n; i++) {
   for(int j =1; j <= n;  j++) {
      m++;
   }
}

Orden cúbico O (n ^ 3)

• El orden cúbico está anidado con 3 niveles de n bucles

k-ésimo orden O (n ^ k)

• El k-ésimo orden está anidado k niveles de n ciclos

Orden exponencial O (2 ^ n)

public int abc(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return abc(n - 1) + abc(n - 2);
    }
}

• T (n) = T (n-1) + T (n-2) +1, donde sumar 1 significa una ejecución
• T (n) = T (n-1) + T (n-2) es una secuencia de Fibonacci (secuencia de Fibonacci, secuencia de sección áurea), que puede ser probada por inducción matemática (MI). Se puede marcar O ((5/3) ^ n), simplificado a O (2 ^ n)

Complejidad espacial

• La complejidad del espacio es una medida de la cantidad de espacio de almacenamiento que un algoritmo ocupa temporalmente durante su funcionamiento. Algunos algoritmos ocupan más espacio de almacenamiento a medida que n aumenta, como la clasificación rápida, la clasificación por fusión, etc.
  * 目前趋势上, 算法主要关注的是时间复杂度. 还有市面上的 如 缓存系统, 基数排序算法等也都是空间换了时间, 提升了程序的执行速度

Si lo encuentra útil, por favor haga clic en Me gusta ~ ¡¡Gracias !!