Visão geral
Outros deram bons exemplos de diagramas, como os diagramas de árvore. Não vi nenhum exemplo simples de código. Portanto, além da minha explicação, fornecerei alguns algoritmos com instruções de impressão simples para ilustrar a complexidade de diferentes categorias de algoritmos.
Primeiro, você deseja ter uma idéia geral do Logaritmo, que pode ser obtida em https://en.wikipedia.org/wiki/Logarithm . Uso das ciências naturais ee registro natural. Os discípulos da engenharia usarão o log_10 (base 10 do log) e os cientistas da computação usarão muito o log_2 (base 2 do log), uma vez que os computadores são binários. Às vezes, você verá as abreviações do log natural como ln(), os engenheiros normalmente deixam o _10 desativado e apenas usam log()e o log_2 é abreviado como lg(). Todos os tipos de logaritmos crescem de maneira semelhante, é por isso que compartilham a mesma categoria de log(n).
Quando você olha os exemplos de código abaixo, recomendo olhar O (1), O (n) e O (n ^ 2). Depois de ser bom com eles, olhe para os outros. Incluí exemplos limpos e variações para demonstrar como as mudanças sutis ainda podem resultar na mesma categorização.
Você pode pensar em O (1), O (n), O (logn) etc. como classes ou categorias de crescimento. Algumas categorias levarão mais tempo do que outras. Essas categorias nos ajudam a ordenar o desempenho do algoritmo. Alguns cresceram mais rápido à medida que a entrada n cresce. A tabela a seguir demonstra o referido crescimento numericamente. Na tabela abaixo, considere log (n) como o limite máximo de log_2.
Exemplos de código simples de várias grandes categorias O:
O (1) - Exemplos de tempo constante:
O algoritmo 1 imprime olá uma vez e não depende de n, portanto sempre será executado em tempo constante, como é O(1).
print "hello";
O algoritmo 2 imprime olá 3 vezes, no entanto, não depende do tamanho da entrada. Mesmo quando n cresce, esse algoritmo sempre imprime olá apenas 3 vezes. Dito isto 3, é uma constante, então esse algoritmo também é O(1).
print "hello";
print "hello";
print "hello";
O (log (n)) - Exemplos logarítmicos:
- Algoritmo 3 - Funciona como "log_2"
O algoritmo 3 demonstra um algoritmo que é executado em log_2 (n). Observe que a pós-operação do loop for multiplica o valor atual de i por 2, ivaria de 1 a 2 a 4 a 8 a 16 a 32 ...
for(int i = 1; i <= n; i = i * 2)
print "hello";
- Algoritmo 4 - Funciona como "log_3"
O algoritmo 4 demonstra log_3. O aviso ivaria de 1 a 3 a 9 a 27 ...
for(int i = 1; i <= n; i = i * 3)
print "hello";
- Algoritmo 5 - Funciona como "log_1.02"
O algoritmo 5 é importante, pois ajuda a mostrar que, desde que o número seja maior que 1 e o resultado seja multiplicado repetidamente contra si mesmo, você está procurando um algoritmo logarítmico.
for(double i = 1; i < n; i = i * 1.02)
print "hello";
O (n) - Exemplos de tempo linear:
Esse algoritmo é simples, que imprime olá n vezes.
for(int i = 0; i < n; i++)
print "hello";
Este algoritmo mostra uma variação, na qual imprimirá olá n / 2 vezes. n / 2 = 1/2 * n. Ignoramos a constante 1/2 e vemos que esse algoritmo é O (n).
for(int i = 0; i < n; i = i + 2)
print "hello";
O (n * log (n)) - nlog (n) Exemplos:
Pense nisso como uma combinação de O(log(n))e O(n). O aninhamento dos loops for nos ajuda a obter oO(n*log(n))
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
O algoritmo 9 é como o algoritmo 8, mas cada um dos loops permitiu variações, o que ainda resulta no resultado final sendo O(n*log(n))
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
O (n ^ 2) - n ao quadrado Exemplos:
O(n^2) é obtido facilmente aninhando o padrão para loops.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
Como o algoritmo 10, mas com algumas variações.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
O (n ^ 3) - n em cubo Exemplos:
É como o algoritmo 10, mas com 3 loops em vez de 2.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
Como o algoritmo 12, mas com algumas variações que ainda produzem O(n^3).
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
Sumário
O exemplo acima fornece vários exemplos diretos e variações para ajudar a demonstrar que mudanças sutis podem ser introduzidas que realmente não alteram a análise. Espero que isso lhe dê informações suficientes.
