Quais são as características de um

Às vezes, é fácil identificar a complexidade de tempo de um algoritmo, examinando-o cuidadosamente. Algoritmos com dois loops aninhados de são obviamente . Algoritmos que explore todas as combinações possíveis de grupos de dois valores são obviamente .N 2 N 2 $N$$N^2$$N$$2^N$

No entanto, não sei como "detectar" um algoritmo com complexidade . Uma implementação de fusão recursiva, por exemplo, é uma. Quais são as características comuns do mergesort ou de outros algoritmos que me dariam uma pista se eu estivesse analisando uma?Θ ( N log N $\Theta(N \log N)$$\Theta(N \log N)$

Tenho certeza de que há mais de uma maneira pela qual um algoritmo pode ter a complexidade , para que todas e quaisquer respostas sejam apreciadas. Aliás, estou buscando características e dicas gerais, não provas rigorosas.$\Theta(N \log N)$

Seu arquetípico é um algoritmo de dividir e conquistar , que divide (e recombina) o trabalho em tempo linear e se repete sobre as peças. A classificação por mesclagem funciona dessa maneira: gaste tempo dividindo a entrada em duas partes aproximadamente iguais, classifique recursivamente cada peça e gaste tempo combinando as duas metades classificadas.O ( n ) Θ ( n $\Theta(n \log n)$$O(n)$$\Theta(n)$

Intuitivamente, continuando a idéia de dividir e conquistar, cada estágio de divisão leva um tempo linear no total, porque o aumento no número de peças a serem divididas corresponde exatamente à diminuição no tamanho das peças, pois o tempo gasto pela divisão é linear. O tempo total de execução é o produto do custo total de um estágio de divisão multiplicado pelo número de estágios de divisão. Como o tamanho das peças é dividido pela metade a cada vez, existem estágios de divisão do , portanto o tempo total de execução é n ⋅ log ( n ) . (Até uma constante multiplicativa, a base do logaritmo é irrelevante.)$\log_2(n)$$n \cdot \log(n)$

Colocando-o nas equações (), uma maneira de estimar o tempo de execução de um algoritmo é expressá-lo recursivamente: T ( n ) = 2 T ( n / 2 ) + Θ ( n ) . É claro que esse algoritmo leva mais que o tempo linear e podemos ver quanto mais dividindo por n : T ( n $T(n)$$T(n) = 2 T(n/2) + \Theta(n)$$n$ Quandondobra,T(n)/naumenta em uma quantidade constante:T(n)/naumenta logaritmicamente, ou seja,T(n)=Θ(nlogn).

Este é um exemplo de um padrão mais geral: o teorema mestre . Para qualquer algoritmo recursivo que divide a sua entrada de tamanho em um pedaços de tamanho n / b e leva um tempo f ( n ) para realizar a divisão e recombinação, o satisfaz tempo de execução T ( n ) = um ⋅ T ( n / b ) + f ( n ) . Isto conduz a uma forma fechada que depende dos valores de um e b e a forma de$n$$a$$n/b$$f(n)$$T(n) = a \cdot T(n/b) + f(n)$$a$$b$ . Se a = b e f ( n ) = Θ ( n ) , o teorema mestre declara que T ( n ) = Θ ( n log n ) .$f$$a = b$$f(n) = \Theta(n)$$T(n) = \Theta(n \log n)$

Duas outras categorias de algoritmos que levam :$\Theta(n \log n)$

Algoritmos em que cada item é processado por vez e leva tempo logarítmico para processar cada item (por exemplo, HeapSort ou muitos dos algoritmos de geometria computacional de varredura de avião).

Algoritmos em que o tempo de execução é dominado por uma etapa de pré-processamento de classificação. (Por exemplo, no algoritmo de Kruskal para árvore de abrangência mínima, podemos classificar as arestas por peso como o primeiro passo).

Outra categoria: os algoritmos nos quais a saída possui tamanho e, portanto, Θ ( n log n ) o tempo de execução é linear no tamanho da saída .$\Theta(n \log n)$$\Theta(n \log n)$

Embora os detalhes de tais algoritmos usem frequentemente técnicas de dividir e conquistar, eles não precisam necessariamente. O tempo de execução vem fundamentalmente da pergunta que está sendo feita e, portanto, acho que vale a pena mencionar separadamente.

Isso ocorre nas estruturas de dados baseadas em uma árvore de pesquisa binária aumentada, em que cada nó armazena uma estrutura de dados de tamanho linear para pesquisar sobre as folhas na subárvore desse nó. Tais estruturas de dados surgem frequentemente na pesquisa por faixa geométrica e geralmente são baseadas em um esquema de decomposição . Veja a Pesquisa da Agarwal .

$O(n \log n)$$O(\log n)$

$O(n\log n)$$k$$O(n)$$O(n)$$O(n)$

Esses são tipicamente algoritmos da variedade "dividir e conquistar", em que o custo de dividir e combinar subsoluções não é "muito grande". Dê uma olhada nesta FAQ para ver que tipos de recorrências causam esse comportamento.

Normalmente, os algoritmos de divisão e conquista renderão complexidade O (N log N).

$O(n \log n)$

for (i = 0; i < constant; i++){
    for(j = 0; j < n; j++){
        // Do some O(1) stuff on the input
    }
}

// Alternative Variant:
for (i = 0; i < constant; i++){
    for(j = n; j < constant; j++){
        // Do some O(1) stuff on the input
    }
}

$O(n^2)$

Não posso dar um exemplo concreto de um algoritmo que use esse loop, mas ele aparece frequentemente ao codificar algoritmos personalizados.