[Estructura de datos] Análisis de complejidad

Llega oferta, cava amigos a recoger! Estoy participando en el evento de registro de reclutamiento de primavera de 2022, haga clic para ver los detalles del evento .

1 ¿Por qué necesita el análisis de complejidad?

1. Los resultados de la prueba dependen mucho del entorno de prueba en diferentes entornos de hardware, y el efecto de probar el mismo código es diferente. Entonces el análisis de complejidad tiene las características de bajo costo y alta eficiencia.
2. Los resultados de la prueba se ven muy afectados por el tamaño de los datos. Por ejemplo, el algoritmo de clasificación, el orden de la clasificación es diferente y el tiempo de ejecución de la clasificación es muy diferente. Si el tamaño de los datos de prueba es pequeño, los resultados de la prueba no pueden reflejar verdaderamente el rendimiento del algoritmo. Por ejemplo, para la clasificación de datos a pequeña escala, la clasificación por inserción puede ser más rápida que la clasificación rápida.

2. Notación de complejidad Big 0

La eficiencia de ejecución de un algoritmo es generalmente el tiempo que lleva ejecutar el código del algoritmo. Entonces, ¿cómo obtener el tiempo de ejecución del código? Enumerar el código primero supone que cada línea de código tarda el mismo tiempo en ejecutarse.

int calc(int n)
{
  int sum=0;//执行一个time
  int i=1;//执行一个time
  int j=1;//执行一个time
  //循环了n遍 所以是2n*time
  //从此整个时间T(n) = (2n2+2n+3)*time 
  for(;i<=n;++i)
  {
      j=1;
      for(;j<=n;j++)
      {
         sum=sum+i*j
      }
  }
}
复制代码

Una regla importante que surge de aquí es que el tiempo de ejecución T(n) de todos los códigos y la ejecución de cada línea de código son proporcionales a n en este tiempo Tn=O(f(n)). T(n)=2n ² +2n+3 aparece arriba, solo necesitamos registrar una magnitud máxima. Por ejemplo T(n)=O(n ² ).

3. Tres métodos de análisis de la complejidad del tiempo

1. Solo concéntrese en la pieza de código con la mayor cantidad de bucles. Notación Big O, que representa una tendencia cambiante. Solo necesitamos preocuparnos por la magnitud de un pedido máximo. Por ejemplo el siguiente código

int calc(int n)
{
    int sum=0;
    int i=0;
    for(;i<=n;++i)
    {
       sum=sum+i;
    }
    return sum;
}
复制代码

    Verifique la parte del código directamente aquí.Estas dos líneas de código se ejecutan n veces, por lo que la complejidad de tiempo total es O(n)

2. La complejidad total de la regla de la suma es igual al código de mayor magnitud

int calc(int n)
{
  int sum=0;//执行一个time
  int i=1;//执行一个time
  int j=1;//执行一个time

  int p = 0;
  for(int p=0;p<n;p++)
  {
      sum=sum+p;
  }
  sum=0;
  //循环了n遍 所以是2n*time
  //从此整个时间T(n) = (2n2+2n+3)*time 
  for(;i<=n;++i)
  {
      j=1;
      for(;j<=n;j++)
      {
         sum=sum+i*j
      }
  }
}
复制代码

    El primer bucle p en este código se repite n veces, sin importar si este n es 100, 1000, etc., es un tiempo de nivel de producción. De manera similar, el segundo código del segundo bucle es O(n ² ), por lo que el resultado final es O(n ² )

3. Regla de multiplicación La complejidad del código anidado es igual al producto de la complejidad del código dentro y fuera del anidamiento Suponiendo que T1(n)=O(n), T2(n)=O(n), entonces T(n) =T1(n)*T2(n)=O(n ² )

Cuatro análisis comunes de la complejidad del tiempo

1. ¿Cuáles son las complejidades comunes?
2. 0(1)

int i=2;
int j=3;
int sum=i+j;
复制代码

En general, si el tiempo de ejecución del código no crece con n, entonces es O(1). El truco es que no hay bucles, recursión, etc. en el programa.

3. O (logn) suma O (nlogn)

int i=1;
while(i<=n)
{
   i=i*2;
}
复制代码

Aquí i comienza desde 1 y se multiplica por 2 cada vez hasta que i es menor que n y termina. Es decir, 2 ⁰ , 2 ¹ ..... 2 ^x , entonces 2 ^x =n, x=log2n En este momento, si i=i*4, es decir x=log ₄ n, entonces log ₄ n es en realidad es igual a log ₄ 2*log ₂ n, entonces, ¿qué es O(log ₄ n)=O(C*log ₂ n) Mencionamos nuestra constante C antes, que puede ignorarse. Entonces O(log4n)=O(log2n).En la representación de complejidad de tiempo logarítmico, ignore la complejidad de tiempo logarítmico

4 O(m+n) y O(m*n)

int cal(int m, int n)
{
  int sum_1 = 0; 
  int i = 1; 
  for (; i < m; ++i)
  {    
    sum_1 = sum_1 + i; 
  } 
 int sum_2 = 0; 
 int j = 1;
 for (; j < n; ++j)
 { 
    sum_2 = sum_2 + j; 
 }  
return sum_1 + sum_2; } 
}
复制代码

La magnitud de m y n aquí es demasiado grande para predecir

5. La complejidad de los algoritmos comunes en las entrevistas

1. Ordenar relacionado
2. Árbol binario relacionado

Seis Resumen

1. El análisis de la complejidad del aprendizaje nos ayuda a escribir mejor código.
2. Los puntos principales del análisis de complejidad (1) Una sola pieza de código analiza la alta frecuencia. Por ejemplo, mire el bucle (2) y tome el código de varios segmentos más grande. Por ejemplo, hay bucles de un solo nivel y bucles de varios niveles. Tome el código anidado de alto nivel (3) para encontrar el producto. como la recursividad
3. Complejidad común(1) Orden polinomial O(1) Orden constante O(logn) Orden logarítmico O(n) Orden lineal O(n ² ) Orden cuadrático(2) No polinomio Orden factorial exponencial