[Estrutura de Dados] Análise de Complexidade

Oferta chega, cavar amigos para pegar! Estou participando do Evento Check-In de Recrutamento da Primavera de 2022, clique para ver os detalhes do evento .

1 Por que você precisa de análise de complexidade?

1. Os resultados do teste são muito dependentes do ambiente de teste em diferentes ambientes de hardware e o efeito de testar o mesmo código é diferente. Então a análise de complexidade tem as características de baixo custo e alta eficiência.
2. Os resultados do teste são muito afetados pelo tamanho dos dados, por exemplo, o algoritmo de ordenação, a ordem da ordenação é diferente e o tempo de execução da ordenação é muito diferente. Se o tamanho dos dados de teste for pequeno, os resultados do teste não poderão refletir verdadeiramente o desempenho do algoritmo. Por exemplo, para classificação de dados em pequena escala, a classificação por inserção pode ser mais rápida que a classificação rápida.

2. Notação de complexidade 0 grande

A eficiência de execução de um algoritmo é geralmente o tempo que leva para executar o código do algoritmo. Então, como obter o tempo de execução do código? Listar o código primeiro pressupõe que cada linha de código leva o mesmo tempo para ser executada.

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
      }
  }
}
复制代码

Uma regra importante que emerge daqui é que o tempo de execução T(n) de todos os códigos e a execução de cada linha de código são proporcionais a n neste momento Tn=O(f(n)). T(n)=2n ² +2n+3 aparece acima, só precisamos registrar uma magnitude máxima. Por exemplo T(n)=O(n2 ⁾ .

3. Três métodos de análise de complexidade de tempo

1. Concentre-se apenas no pedaço de código com a notação Big O com mais loops, o que representa uma tendência de mudança. Só precisamos nos preocupar com a magnitude de uma ordem máxima. Por exemplo o seguinte código

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

    Verifique a parte do código diretamente aqui. Essas duas linhas de código são executadas n vezes, então a complexidade de tempo total é O(n)

2. A complexidade total da regra de adição é igual ao código com a maior magnitude

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
      }
  }
}
复制代码

    O primeiro loop p neste código faz um loop n vezes, não importa se este n é 100, 1000, etc., é um tempo de nível de produção. Da mesma forma, o segundo código de loop é O(n ² ), então o resultado final é O(n ² )

3. Regra de multiplicação A complexidade do código aninhado é igual ao produto da complexidade do código dentro e fora do aninhamento Assumindo T1(n)=O(n), T2(n)=O(n), então T(n) =T1(n)* ^T2 (n)=O(n2 )

Quatro análises comuns de complexidade de tempo

1. Quais são as complexidades comuns
2. 0(1)

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

Em geral, se o tempo de execução do código não cresce com n, então é O(1). O truque é que não há loops, recursão, etc. no programa

3. O (logn) soma O (nlogn)

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

Aqui i começa em 1 e multiplica por 2 todas as vezes até que i seja menor que n e termine. Ou seja, 2 ⁰ , 2 ¹ ..... 2 ^x , então 2 ^x =n, x=log2n. Neste momento, se i=i*4, que é x=log ₄ n, então log ₄ n é na verdade igual a log ₄ 2*log ₂ n, então qual é O(log ₄ n)=O(C*log ₂ n) Mencionamos nossa constante C antes, que pode ser ignorada. Então O(log4n)=O(log2n). Na representação da complexidade de tempo logarítmica, ignore a complexidade de tempo logarítmica

4 O(m+n) e 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; } 
}
复制代码

A magnitude de m e n aqui é muito grande para prever

5. A complexidade dos algoritmos comuns em entrevistas

1. Ordenar relacionado
2. Árvore binária relacionada

Seis Resumo

1. A análise de complexidade de aprendizado nos ajuda a escrever um código melhor.
2. Os principais pontos da análise de complexidade (1) Um único pedaço de código analisa a alta frequência. Por exemplo, observe o loop (2) e pegue o maior código de vários segmentos. Por exemplo, existem loops de nível único e loops de vários níveis. Pegue o código aninhado de alto nível (3) para encontrar o produto. como recursão
3. Complexidade comum(1) Ordem polinomial O(1) Ordem constante O(logn) Ordem logarítmica O(n) Ordem linear O(n ² ) Ordem quadrada(2) Não polinomial Ordem fatorial exponencial