Como alguém sabe qual notação de análise de complexidade de tempo usar?

Na maioria das aulas introdutórias de algoritmo, são apresentadas notações como (Big O) e , e um aluno geralmente aprende a usar uma delas para encontrar a complexidade do tempo.$O$$\Theta$

No entanto, existem outras notações, como , e . Existem cenários específicos em que uma notação seria preferível a outra?Ω $o$$\Omega$$\omega$

Você está se referindo à notação Landau . Eles não são símbolos diferentes para a mesma coisa, mas têm significados totalmente diferentes. Qual é "preferível" depende inteiramente da afirmação desejada.

f g ≤ f ∈ o ( g ) $f \in \cal{O}(g)$ significa que cresce no máximo tão rápido quanto , assintoticamente e até um fator constante; pense nisso como um . é a forma mais rígida, ou seja, .$f$$g$$\leq$$f \in o(g)$$<$

f g ω f ∈ Ω ( g ) g ∈ O ( f $f \in \Omega(g)$ tem o significado simétrico: cresce pelo menos tão rápido quanto . é seu primo mais rígido. Você pode ver que é equivalente a .$f$$g$$\omega$$f \in \Omega(g)$$g \in \cal{O}(f)$

f g f ∈ S ( g ) ∩ ohms ( g ) f ~ g Θ $f \in \Theta(g)$ significa que cresce tão rápido quanto ; formalmente . (igualdade assintótica) é sua forma mais forte. Geralmente queremos dizer quando usamos .$f$$g$$f \in \cal{O}(g) \cap \Omega(g)$$f \sim g$$\Theta$$\cal{O}$

Observe como e seus irmãos são classes de função . É importante estar ciente disso e de suas definições precisas - que podem diferir dependendo de quem está falando - ao fazer "aritmética" com eles.$\cal{O}(g)$

Ao provar as coisas, trabalhe com sua definição precisa. Existem muitas definições para os símbolos Landau (todas com a mesma intuição básica), algumas das quais equivalentes em alguns conjuntos de funções, mas não em outras.

Leitura sugerida:

• Quais são as regras para sinais de igual com big-O e little-o?
• Classificando funções por crescimento assintótico
• Como O e Ω se relacionam com o pior e o melhor caso?
• Notação O grande aninhada
• Definição de para funções negativas$\Theta$
• Qual é o significado de ? $O(m+n)$
  O (mn) é considerado crescimento "linear" ou "quadrático"?
• Soma dos termos do Landau revisitados
• O que big O significa como termo de uma razão de aproximação?
• Qualquer outra pergunta sobre assintóticos e notação landau como exercício.

Se você estiver interessado em usar a notação Landau de maneira rigorosa e sólida, poderá estar interessado em trabalhos recentes de Rutanen et al. [1] Eles formulam critérios necessários e suficientes para a notação assintótica à medida que os usamos em algoritmos, mostram que a definição comum falha em atendê-los e fornece uma (na verdade) definição viável.

1. Uma definição geral da notação O para análise de algoritmos por K. Rutanen et al. (2015)

Big O: limite superior

"Big O" ( ) é de longe o mais comum. Quando você analisa a complexidade de um algoritmo, na maioria das vezes, o que importa é ter um limite superior sobre a rapidez com que o tempo de execução cresce quando o tamanho da entrada aumenta. Basicamente, queremos saber que a execução do algoritmo não vai demorar "muito tempo". Não podemos expressar isso em unidades de tempo reais (segundos), porque isso dependeria da implementação precisa (da maneira como o programa é escrito, da qualidade do compilador, da rapidez com que o processador da máquina é ...). Portanto, avaliamos o que não depende de tais detalhes, que é quanto tempo leva para executar o algoritmo quando alimentamos uma entrada maior. E nos preocupamos principalmente quando podemos ter certeza de que o programa está concluído, por isso geralmente queremos saber que isso levará uma quantidade tão grande de tempo ou menos.$O$

Dizer que um algoritmo tem um tempo de execução de para um tamanho de entrada significa que existe alguma constante modo que o algoritmo é concluído na maioria das etapas de , ou seja, o tempo de execução do algoritmo cresce no máximo tão rápido quanto (até um fator de escala). Observando o tempo de execução do algoritmo para o tamanho de entrada , informalmente significa que até algum fator de escala.n K $O(f(n))$$n$$K$f T ( n ) n O ( n ) T ( n ) ≤ f ( n $K \, f(n)$$f$$T(n)$$n$$O(n)$$T(n) \le f(n)$

Limite inferior

Às vezes, é útil ter mais informações que um limite superior. é o inverso de : expressa que uma função cresce pelo menos tão rápido quanto outra. significa que para uma constante , ou, para ser informal, acima a algum fator de escala.O T ( n ) = Ω ( g ( n ) ) T ( N ) ≥ K ′ g ( n ) K ′ T ( n ) ≥ g ( n $\Omega$$O$$T(n) = \Omega(g(n))$$T(N) \ge K' g(n)$$K'$$T(n) \ge g(n)$

Quando o tempo de execução do algoritmo pode ser determinado com precisão, combina e : ele expressa que a taxa de crescimento de uma função é conhecida, até um fator de escala. significa que para algumas constantes e . Informalmente, até algum fator de escala.O Ω T ( n ) = Θ ( h ( n ) ) K h ( n ) ≥ T ( n ) ≥ K ′ h ( n ) K K ′ T ( n ) ≈ h ( n $\Theta$$O$$\Omega$$T(n) = \Theta(h(n))$$K h(n) \ge T(n) \ge K' h(n)$$K$$K'$$T(n) \approx h(n)$

Considerações adicionais

O "pequeno" e são usados ​​com muito menos frequência na análise de complexidade. Pouco é mais forte que grande ; onde indica um crescimento que não é mais rápido, indica que o crescimento é estritamente mais lento. Por outro lado, indica um crescimento estritamente mais rápido.ω ó ó ó ó $o$$\omega$$o$$O$$O$$o$$\omega$

Eu fui um pouco informal na discussão acima. A Wikipedia possui definições formall e uma abordagem mais matemática.

Lembre-se de que o uso do sinal de igual em e similares é um nome impróprio. A rigor, é um conjunto de funções da variável , e devemos escrever .O ( f ( n ) ) n T ∈ O ( f $T(n) = O(f(n))$$O(f(n))$$n$$T \in O(f)$

Exemplo: alguns algoritmos de classificação

Como isso é bastante seco, deixe-me dar um exemplo. A maioria dos algoritmos de classificação possui um tempo de execução quadrático no pior caso, ou seja, para uma entrada do tamanho , o tempo de execução do algoritmo é . Por exemplo, a classificação de seleção tem um tempo de execução , porque a seleção do ésimo elemento requer comparações , para um total de comparações. De fato, o número de comparações é sempre exatamente , que cresce como . Portanto, podemos ser mais precisos sobre a complexidade temporal da classificação: é Θ ( n 2 ) .O ( n 2 ) O ( n 2 ) k n - k n ( n - 1 ) / 2 n ( n - 1 ) / 2 n $n$$O(n^2)$$O(n^2)$$k$$n-k$$n(n-1)/2$$n(n-1)/2$$n^2$$\Theta(n^2)$

Agora faça a classificação por mesclagem . A classificação de mesclagem também é quadrática ( ). Isso é verdade, mas não muito preciso. A classificação de mesclagem na verdade tem um tempo de execução de O ( $O(n^2)$ no pior dos casos. Como a classificação por seleção, o fluxo de trabalho da classificação por mesclagem é essencialmente independente da forma da entrada e seu tempo de execução é sempre$O(n \: \mathrm{lg}(n))$ até um fator multiplicativo constante, ou seja, é.$n \: \mathrm{lg}(n)$$\Theta(n \: \mathrm{lg}(n))$

Em seguida, considere o quicksort . Quicksort é mais complexo. Certamente é . Além disso, o pior caso de quicksort é quadrático: o pior caso é . No entanto, o melhor caso de quicksort (quando a entrada já está classificada) é linear: o melhor que podemos dizer para um limite inferior ao quicksort em geral é . Não repetirei a prova aqui, mas a complexidade média do quicksort (a média obtida de todas as permutações possíveis da entrada) é .Θ ( n 2 ) Ω ( n ) Θ ( $O(n^2)$$\Theta(n^2)$$\Omega(n)$$\Theta(n \: \mathrm{lg}(n))$

Há resultados gerais sobre a complexidade dos algoritmos de classificação em configurações comuns. Suponha que um algoritmo de classificação possa comparar apenas dois elementos por vez, com um resultado sim ou não ( ou x > y ). Então é óbvio que o tempo de execução de qualquer algoritmo de classificação é sempre Ω ( n ) (onde n é o número de elementos a serem classificados), porque o algoritmo precisa comparar todos os elementos pelo menos uma vez para saber onde ele se encaixará. Esse limite inferior pode ser atingido, por exemplo, se a entrada já estiver classificada e o algoritmo apenas comparar cada elemento com o próximo e mantê-los em ordem (ou seja, n - $x \le y$$x > y$$\Omega(n)$$n$$n-1$comparações). O que é menos óbvio é que o tempo máximo de execução é necessariamente . É possível que o algoritmo às vezes faça menos comparações, mas deve haver um K constante, demodo que, para qualquer tamanho de entrada n , haja pelo menos uma entrada na qual o algoritmo faça mais do quecomparaçõesde K n l g ( n ) . A idéia da prova é construir a árvore de decisão do algoritmo, ou seja, seguir as decisões que o algoritmo toma do resultado de cada comparação. Como cada comparação retorna um resultado sim ou não, a árvore de decisão é uma árvore binária. Existem n $\Omega(n \: \mathrm{lg}(n))$$K$$n$$K n \mathrm{lg}(n)$$n!$possíveis permutações da entrada, e o algoritmo precisa distinguir entre todas elas; portanto, o tamanho da árvore de decisão é . Como a árvore é uma árvore binária, é necessária uma profundidade de Θ ( l g ( n ! ) ) = Θ ( $n!$ para ajustar todos esses nós. A profundidade é o número máximo de decisões que o algoritmo toma, portanto, a execução do algoritmo envolve pelo menos tantas comparações: o tempo máximo de execução é Ω ( $\Theta(\mathrm{lg}(n!)) = \Theta(n\:\mathrm{lg}(n))$ .$\Omega(n \: \mathrm{lg}(n))$

¹ _{Ou outro consumo de recursos, como espaço na memória. Nesta resposta, considero apenas o tempo de execução.}

$O$$\Omega$$\Theta$$\Theta$